OLD | NEW |
| (Empty) |
1 #ifndef __vulkan_h_ | |
2 #define __vulkan_h_ 1 | |
3 | |
4 #ifdef __cplusplus | |
5 extern "C" { | |
6 #endif | |
7 | |
8 /* | |
9 ** Copyright (c) 2015-2016 The Khronos Group Inc. | |
10 ** | |
11 ** Permission is hereby granted, free of charge, to any person obtaining a | |
12 ** copy of this software and/or associated documentation files (the | |
13 ** "Materials"), to deal in the Materials without restriction, including | |
14 ** without limitation the rights to use, copy, modify, merge, publish, | |
15 ** distribute, sublicense, and/or sell copies of the Materials, and to | |
16 ** permit persons to whom the Materials are furnished to do so, subject to | |
17 ** the following conditions: | |
18 ** | |
19 ** The above copyright notice and this permission notice shall be included | |
20 ** in all copies or substantial portions of the Materials. | |
21 ** | |
22 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
23 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
24 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
25 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | |
26 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | |
27 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
28 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. | |
29 */ | |
30 | |
31 /* | |
32 ** This header is generated from the Khronos Vulkan XML API Registry. | |
33 ** | |
34 */ | |
35 | |
36 | |
37 #define VK_VERSION_1_0 1 | |
38 #include "vk_platform.h" | |
39 | |
40 #define VK_MAKE_VERSION(major, minor, patch) \ | |
41 (((major) << 22) | ((minor) << 12) | (patch)) | |
42 | |
43 // Vulkan API version supported by this file | |
44 #define VK_API_VERSION VK_MAKE_VERSION(1, 0, 3) | |
45 | |
46 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) | |
47 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) | |
48 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) | |
49 | |
50 #define VK_NULL_HANDLE 0 | |
51 | |
52 | |
53 | |
54 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; | |
55 | |
56 | |
57 #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X6
4) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__
powerpc64__) | |
58 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object#
#_T *object; | |
59 #else | |
60 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t objec
t; | |
61 #endif | |
62 | |
63 | |
64 | |
65 typedef uint32_t VkFlags; | |
66 typedef uint32_t VkBool32; | |
67 typedef uint64_t VkDeviceSize; | |
68 typedef uint32_t VkSampleMask; | |
69 | |
70 VK_DEFINE_HANDLE(VkInstance) | |
71 VK_DEFINE_HANDLE(VkPhysicalDevice) | |
72 VK_DEFINE_HANDLE(VkDevice) | |
73 VK_DEFINE_HANDLE(VkQueue) | |
74 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) | |
75 VK_DEFINE_HANDLE(VkCommandBuffer) | |
76 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) | |
77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) | |
78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) | |
79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) | |
80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) | |
81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) | |
82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) | |
83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) | |
84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) | |
85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) | |
86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) | |
87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) | |
88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) | |
89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) | |
90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) | |
91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) | |
92 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) | |
93 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) | |
94 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) | |
95 | |
96 #define VK_LOD_CLAMP_NONE 1000.0f | |
97 #define VK_REMAINING_MIP_LEVELS (~0U) | |
98 #define VK_REMAINING_ARRAY_LAYERS (~0U) | |
99 #define VK_WHOLE_SIZE (~0ULL) | |
100 #define VK_ATTACHMENT_UNUSED (~0U) | |
101 #define VK_TRUE 1 | |
102 #define VK_FALSE 0 | |
103 #define VK_QUEUE_FAMILY_IGNORED (~0U) | |
104 #define VK_SUBPASS_EXTERNAL (~0U) | |
105 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 | |
106 #define VK_UUID_SIZE 16 | |
107 #define VK_MAX_MEMORY_TYPES 32 | |
108 #define VK_MAX_MEMORY_HEAPS 16 | |
109 #define VK_MAX_EXTENSION_NAME_SIZE 256 | |
110 #define VK_MAX_DESCRIPTION_SIZE 256 | |
111 | |
112 | |
113 typedef enum VkPipelineCacheHeaderVersion { | |
114 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, | |
115 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERS
ION_ONE, | |
116 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSIO
N_ONE, | |
117 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERS
ION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), | |
118 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF | |
119 } VkPipelineCacheHeaderVersion; | |
120 | |
121 typedef enum VkResult { | |
122 VK_SUCCESS = 0, | |
123 VK_NOT_READY = 1, | |
124 VK_TIMEOUT = 2, | |
125 VK_EVENT_SET = 3, | |
126 VK_EVENT_RESET = 4, | |
127 VK_INCOMPLETE = 5, | |
128 VK_ERROR_OUT_OF_HOST_MEMORY = -1, | |
129 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, | |
130 VK_ERROR_INITIALIZATION_FAILED = -3, | |
131 VK_ERROR_DEVICE_LOST = -4, | |
132 VK_ERROR_MEMORY_MAP_FAILED = -5, | |
133 VK_ERROR_LAYER_NOT_PRESENT = -6, | |
134 VK_ERROR_EXTENSION_NOT_PRESENT = -7, | |
135 VK_ERROR_FEATURE_NOT_PRESENT = -8, | |
136 VK_ERROR_INCOMPATIBLE_DRIVER = -9, | |
137 VK_ERROR_TOO_MANY_OBJECTS = -10, | |
138 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, | |
139 VK_ERROR_SURFACE_LOST_KHR = -1000000000, | |
140 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, | |
141 VK_SUBOPTIMAL_KHR = 1000001003, | |
142 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, | |
143 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, | |
144 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, | |
145 VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, | |
146 VK_RESULT_END_RANGE = VK_INCOMPLETE, | |
147 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1), | |
148 VK_RESULT_MAX_ENUM = 0x7FFFFFFF | |
149 } VkResult; | |
150 | |
151 typedef enum VkStructureType { | |
152 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, | |
153 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, | |
154 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, | |
155 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, | |
156 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, | |
157 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, | |
158 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, | |
159 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, | |
160 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, | |
161 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, | |
162 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, | |
163 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, | |
164 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, | |
165 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, | |
166 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, | |
167 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, | |
168 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, | |
169 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, | |
170 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, | |
171 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, | |
172 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, | |
173 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, | |
174 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, | |
175 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, | |
176 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, | |
177 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, | |
178 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, | |
179 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, | |
180 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, | |
181 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, | |
182 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, | |
183 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, | |
184 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, | |
185 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, | |
186 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, | |
187 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, | |
188 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, | |
189 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, | |
190 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, | |
191 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, | |
192 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, | |
193 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, | |
194 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, | |
195 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, | |
196 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, | |
197 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, | |
198 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, | |
199 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, | |
200 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, | |
201 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, | |
202 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, | |
203 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, | |
204 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, | |
205 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, | |
206 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, | |
207 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, | |
208 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, | |
209 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, | |
210 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, | |
211 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, | |
212 VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, | |
213 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, | |
214 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, | |
215 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
- VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), | |
216 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF | |
217 } VkStructureType; | |
218 | |
219 typedef enum VkSystemAllocationScope { | |
220 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, | |
221 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, | |
222 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, | |
223 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, | |
224 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, | |
225 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, | |
226 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, | |
227 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
- VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), | |
228 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF | |
229 } VkSystemAllocationScope; | |
230 | |
231 typedef enum VkInternalAllocationType { | |
232 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, | |
233 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUT
ABLE, | |
234 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTAB
LE, | |
235 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUT
ABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), | |
236 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF | |
237 } VkInternalAllocationType; | |
238 | |
239 typedef enum VkFormat { | |
240 VK_FORMAT_UNDEFINED = 0, | |
241 VK_FORMAT_R4G4_UNORM_PACK8 = 1, | |
242 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, | |
243 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, | |
244 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, | |
245 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, | |
246 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, | |
247 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, | |
248 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, | |
249 VK_FORMAT_R8_UNORM = 9, | |
250 VK_FORMAT_R8_SNORM = 10, | |
251 VK_FORMAT_R8_USCALED = 11, | |
252 VK_FORMAT_R8_SSCALED = 12, | |
253 VK_FORMAT_R8_UINT = 13, | |
254 VK_FORMAT_R8_SINT = 14, | |
255 VK_FORMAT_R8_SRGB = 15, | |
256 VK_FORMAT_R8G8_UNORM = 16, | |
257 VK_FORMAT_R8G8_SNORM = 17, | |
258 VK_FORMAT_R8G8_USCALED = 18, | |
259 VK_FORMAT_R8G8_SSCALED = 19, | |
260 VK_FORMAT_R8G8_UINT = 20, | |
261 VK_FORMAT_R8G8_SINT = 21, | |
262 VK_FORMAT_R8G8_SRGB = 22, | |
263 VK_FORMAT_R8G8B8_UNORM = 23, | |
264 VK_FORMAT_R8G8B8_SNORM = 24, | |
265 VK_FORMAT_R8G8B8_USCALED = 25, | |
266 VK_FORMAT_R8G8B8_SSCALED = 26, | |
267 VK_FORMAT_R8G8B8_UINT = 27, | |
268 VK_FORMAT_R8G8B8_SINT = 28, | |
269 VK_FORMAT_R8G8B8_SRGB = 29, | |
270 VK_FORMAT_B8G8R8_UNORM = 30, | |
271 VK_FORMAT_B8G8R8_SNORM = 31, | |
272 VK_FORMAT_B8G8R8_USCALED = 32, | |
273 VK_FORMAT_B8G8R8_SSCALED = 33, | |
274 VK_FORMAT_B8G8R8_UINT = 34, | |
275 VK_FORMAT_B8G8R8_SINT = 35, | |
276 VK_FORMAT_B8G8R8_SRGB = 36, | |
277 VK_FORMAT_R8G8B8A8_UNORM = 37, | |
278 VK_FORMAT_R8G8B8A8_SNORM = 38, | |
279 VK_FORMAT_R8G8B8A8_USCALED = 39, | |
280 VK_FORMAT_R8G8B8A8_SSCALED = 40, | |
281 VK_FORMAT_R8G8B8A8_UINT = 41, | |
282 VK_FORMAT_R8G8B8A8_SINT = 42, | |
283 VK_FORMAT_R8G8B8A8_SRGB = 43, | |
284 VK_FORMAT_B8G8R8A8_UNORM = 44, | |
285 VK_FORMAT_B8G8R8A8_SNORM = 45, | |
286 VK_FORMAT_B8G8R8A8_USCALED = 46, | |
287 VK_FORMAT_B8G8R8A8_SSCALED = 47, | |
288 VK_FORMAT_B8G8R8A8_UINT = 48, | |
289 VK_FORMAT_B8G8R8A8_SINT = 49, | |
290 VK_FORMAT_B8G8R8A8_SRGB = 50, | |
291 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, | |
292 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, | |
293 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, | |
294 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, | |
295 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, | |
296 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, | |
297 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, | |
298 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, | |
299 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, | |
300 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, | |
301 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, | |
302 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, | |
303 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, | |
304 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, | |
305 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, | |
306 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, | |
307 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, | |
308 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, | |
309 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, | |
310 VK_FORMAT_R16_UNORM = 70, | |
311 VK_FORMAT_R16_SNORM = 71, | |
312 VK_FORMAT_R16_USCALED = 72, | |
313 VK_FORMAT_R16_SSCALED = 73, | |
314 VK_FORMAT_R16_UINT = 74, | |
315 VK_FORMAT_R16_SINT = 75, | |
316 VK_FORMAT_R16_SFLOAT = 76, | |
317 VK_FORMAT_R16G16_UNORM = 77, | |
318 VK_FORMAT_R16G16_SNORM = 78, | |
319 VK_FORMAT_R16G16_USCALED = 79, | |
320 VK_FORMAT_R16G16_SSCALED = 80, | |
321 VK_FORMAT_R16G16_UINT = 81, | |
322 VK_FORMAT_R16G16_SINT = 82, | |
323 VK_FORMAT_R16G16_SFLOAT = 83, | |
324 VK_FORMAT_R16G16B16_UNORM = 84, | |
325 VK_FORMAT_R16G16B16_SNORM = 85, | |
326 VK_FORMAT_R16G16B16_USCALED = 86, | |
327 VK_FORMAT_R16G16B16_SSCALED = 87, | |
328 VK_FORMAT_R16G16B16_UINT = 88, | |
329 VK_FORMAT_R16G16B16_SINT = 89, | |
330 VK_FORMAT_R16G16B16_SFLOAT = 90, | |
331 VK_FORMAT_R16G16B16A16_UNORM = 91, | |
332 VK_FORMAT_R16G16B16A16_SNORM = 92, | |
333 VK_FORMAT_R16G16B16A16_USCALED = 93, | |
334 VK_FORMAT_R16G16B16A16_SSCALED = 94, | |
335 VK_FORMAT_R16G16B16A16_UINT = 95, | |
336 VK_FORMAT_R16G16B16A16_SINT = 96, | |
337 VK_FORMAT_R16G16B16A16_SFLOAT = 97, | |
338 VK_FORMAT_R32_UINT = 98, | |
339 VK_FORMAT_R32_SINT = 99, | |
340 VK_FORMAT_R32_SFLOAT = 100, | |
341 VK_FORMAT_R32G32_UINT = 101, | |
342 VK_FORMAT_R32G32_SINT = 102, | |
343 VK_FORMAT_R32G32_SFLOAT = 103, | |
344 VK_FORMAT_R32G32B32_UINT = 104, | |
345 VK_FORMAT_R32G32B32_SINT = 105, | |
346 VK_FORMAT_R32G32B32_SFLOAT = 106, | |
347 VK_FORMAT_R32G32B32A32_UINT = 107, | |
348 VK_FORMAT_R32G32B32A32_SINT = 108, | |
349 VK_FORMAT_R32G32B32A32_SFLOAT = 109, | |
350 VK_FORMAT_R64_UINT = 110, | |
351 VK_FORMAT_R64_SINT = 111, | |
352 VK_FORMAT_R64_SFLOAT = 112, | |
353 VK_FORMAT_R64G64_UINT = 113, | |
354 VK_FORMAT_R64G64_SINT = 114, | |
355 VK_FORMAT_R64G64_SFLOAT = 115, | |
356 VK_FORMAT_R64G64B64_UINT = 116, | |
357 VK_FORMAT_R64G64B64_SINT = 117, | |
358 VK_FORMAT_R64G64B64_SFLOAT = 118, | |
359 VK_FORMAT_R64G64B64A64_UINT = 119, | |
360 VK_FORMAT_R64G64B64A64_SINT = 120, | |
361 VK_FORMAT_R64G64B64A64_SFLOAT = 121, | |
362 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, | |
363 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, | |
364 VK_FORMAT_D16_UNORM = 124, | |
365 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, | |
366 VK_FORMAT_D32_SFLOAT = 126, | |
367 VK_FORMAT_S8_UINT = 127, | |
368 VK_FORMAT_D16_UNORM_S8_UINT = 128, | |
369 VK_FORMAT_D24_UNORM_S8_UINT = 129, | |
370 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, | |
371 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, | |
372 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, | |
373 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, | |
374 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, | |
375 VK_FORMAT_BC2_UNORM_BLOCK = 135, | |
376 VK_FORMAT_BC2_SRGB_BLOCK = 136, | |
377 VK_FORMAT_BC3_UNORM_BLOCK = 137, | |
378 VK_FORMAT_BC3_SRGB_BLOCK = 138, | |
379 VK_FORMAT_BC4_UNORM_BLOCK = 139, | |
380 VK_FORMAT_BC4_SNORM_BLOCK = 140, | |
381 VK_FORMAT_BC5_UNORM_BLOCK = 141, | |
382 VK_FORMAT_BC5_SNORM_BLOCK = 142, | |
383 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, | |
384 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, | |
385 VK_FORMAT_BC7_UNORM_BLOCK = 145, | |
386 VK_FORMAT_BC7_SRGB_BLOCK = 146, | |
387 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, | |
388 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, | |
389 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, | |
390 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, | |
391 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, | |
392 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, | |
393 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, | |
394 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, | |
395 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, | |
396 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, | |
397 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, | |
398 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, | |
399 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, | |
400 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, | |
401 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, | |
402 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, | |
403 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, | |
404 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, | |
405 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, | |
406 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, | |
407 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, | |
408 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, | |
409 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, | |
410 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, | |
411 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, | |
412 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, | |
413 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, | |
414 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, | |
415 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, | |
416 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, | |
417 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, | |
418 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, | |
419 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, | |
420 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, | |
421 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, | |
422 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, | |
423 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, | |
424 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, | |
425 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, | |
426 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, | |
427 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINE
D + 1), | |
428 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF | |
429 } VkFormat; | |
430 | |
431 typedef enum VkImageType { | |
432 VK_IMAGE_TYPE_1D = 0, | |
433 VK_IMAGE_TYPE_2D = 1, | |
434 VK_IMAGE_TYPE_3D = 2, | |
435 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, | |
436 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, | |
437 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), | |
438 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF | |
439 } VkImageType; | |
440 | |
441 typedef enum VkImageTiling { | |
442 VK_IMAGE_TILING_OPTIMAL = 0, | |
443 VK_IMAGE_TILING_LINEAR = 1, | |
444 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, | |
445 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, | |
446 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIM
AL + 1), | |
447 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF | |
448 } VkImageTiling; | |
449 | |
450 typedef enum VkPhysicalDeviceType { | |
451 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, | |
452 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, | |
453 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, | |
454 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, | |
455 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, | |
456 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, | |
457 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, | |
458 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSI
CAL_DEVICE_TYPE_OTHER + 1), | |
459 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF | |
460 } VkPhysicalDeviceType; | |
461 | |
462 typedef enum VkQueryType { | |
463 VK_QUERY_TYPE_OCCLUSION = 0, | |
464 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, | |
465 VK_QUERY_TYPE_TIMESTAMP = 2, | |
466 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, | |
467 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, | |
468 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSIO
N + 1), | |
469 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF | |
470 } VkQueryType; | |
471 | |
472 typedef enum VkSharingMode { | |
473 VK_SHARING_MODE_EXCLUSIVE = 0, | |
474 VK_SHARING_MODE_CONCURRENT = 1, | |
475 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, | |
476 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, | |
477 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_E
XCLUSIVE + 1), | |
478 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF | |
479 } VkSharingMode; | |
480 | |
481 typedef enum VkImageLayout { | |
482 VK_IMAGE_LAYOUT_UNDEFINED = 0, | |
483 VK_IMAGE_LAYOUT_GENERAL = 1, | |
484 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, | |
485 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, | |
486 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, | |
487 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, | |
488 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, | |
489 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, | |
490 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, | |
491 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, | |
492 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, | |
493 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, | |
494 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYO
UT_UNDEFINED + 1), | |
495 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF | |
496 } VkImageLayout; | |
497 | |
498 typedef enum VkImageViewType { | |
499 VK_IMAGE_VIEW_TYPE_1D = 0, | |
500 VK_IMAGE_VIEW_TYPE_2D = 1, | |
501 VK_IMAGE_VIEW_TYPE_3D = 2, | |
502 VK_IMAGE_VIEW_TYPE_CUBE = 3, | |
503 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, | |
504 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, | |
505 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, | |
506 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, | |
507 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, | |
508 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VI
EW_TYPE_1D + 1), | |
509 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF | |
510 } VkImageViewType; | |
511 | |
512 typedef enum VkComponentSwizzle { | |
513 VK_COMPONENT_SWIZZLE_IDENTITY = 0, | |
514 VK_COMPONENT_SWIZZLE_ZERO = 1, | |
515 VK_COMPONENT_SWIZZLE_ONE = 2, | |
516 VK_COMPONENT_SWIZZLE_R = 3, | |
517 VK_COMPONENT_SWIZZLE_G = 4, | |
518 VK_COMPONENT_SWIZZLE_B = 5, | |
519 VK_COMPONENT_SWIZZLE_A = 6, | |
520 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, | |
521 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, | |
522 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWI
ZZLE_IDENTITY + 1), | |
523 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF | |
524 } VkComponentSwizzle; | |
525 | |
526 typedef enum VkVertexInputRate { | |
527 VK_VERTEX_INPUT_RATE_VERTEX = 0, | |
528 VK_VERTEX_INPUT_RATE_INSTANCE = 1, | |
529 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, | |
530 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, | |
531 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX
_INPUT_RATE_VERTEX + 1), | |
532 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF | |
533 } VkVertexInputRate; | |
534 | |
535 typedef enum VkPrimitiveTopology { | |
536 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, | |
537 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, | |
538 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, | |
539 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, | |
540 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, | |
541 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, | |
542 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, | |
543 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, | |
544 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, | |
545 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, | |
546 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, | |
547 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, | |
548 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, | |
549 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PR
IMITIVE_TOPOLOGY_POINT_LIST + 1), | |
550 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF | |
551 } VkPrimitiveTopology; | |
552 | |
553 typedef enum VkPolygonMode { | |
554 VK_POLYGON_MODE_FILL = 0, | |
555 VK_POLYGON_MODE_LINE = 1, | |
556 VK_POLYGON_MODE_POINT = 2, | |
557 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, | |
558 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, | |
559 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL +
1), | |
560 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF | |
561 } VkPolygonMode; | |
562 | |
563 typedef enum VkFrontFace { | |
564 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, | |
565 VK_FRONT_FACE_CLOCKWISE = 1, | |
566 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, | |
567 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, | |
568 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_
CLOCKWISE + 1), | |
569 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF | |
570 } VkFrontFace; | |
571 | |
572 typedef enum VkCompareOp { | |
573 VK_COMPARE_OP_NEVER = 0, | |
574 VK_COMPARE_OP_LESS = 1, | |
575 VK_COMPARE_OP_EQUAL = 2, | |
576 VK_COMPARE_OP_LESS_OR_EQUAL = 3, | |
577 VK_COMPARE_OP_GREATER = 4, | |
578 VK_COMPARE_OP_NOT_EQUAL = 5, | |
579 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, | |
580 VK_COMPARE_OP_ALWAYS = 7, | |
581 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, | |
582 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, | |
583 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), | |
584 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF | |
585 } VkCompareOp; | |
586 | |
587 typedef enum VkStencilOp { | |
588 VK_STENCIL_OP_KEEP = 0, | |
589 VK_STENCIL_OP_ZERO = 1, | |
590 VK_STENCIL_OP_REPLACE = 2, | |
591 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, | |
592 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, | |
593 VK_STENCIL_OP_INVERT = 5, | |
594 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, | |
595 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, | |
596 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, | |
597 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, | |
598 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP
_KEEP + 1), | |
599 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF | |
600 } VkStencilOp; | |
601 | |
602 typedef enum VkLogicOp { | |
603 VK_LOGIC_OP_CLEAR = 0, | |
604 VK_LOGIC_OP_AND = 1, | |
605 VK_LOGIC_OP_AND_REVERSE = 2, | |
606 VK_LOGIC_OP_COPY = 3, | |
607 VK_LOGIC_OP_AND_INVERTED = 4, | |
608 VK_LOGIC_OP_NO_OP = 5, | |
609 VK_LOGIC_OP_XOR = 6, | |
610 VK_LOGIC_OP_OR = 7, | |
611 VK_LOGIC_OP_NOR = 8, | |
612 VK_LOGIC_OP_EQUIVALENT = 9, | |
613 VK_LOGIC_OP_INVERT = 10, | |
614 VK_LOGIC_OP_OR_REVERSE = 11, | |
615 VK_LOGIC_OP_COPY_INVERTED = 12, | |
616 VK_LOGIC_OP_OR_INVERTED = 13, | |
617 VK_LOGIC_OP_NAND = 14, | |
618 VK_LOGIC_OP_SET = 15, | |
619 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, | |
620 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, | |
621 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), | |
622 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF | |
623 } VkLogicOp; | |
624 | |
625 typedef enum VkBlendFactor { | |
626 VK_BLEND_FACTOR_ZERO = 0, | |
627 VK_BLEND_FACTOR_ONE = 1, | |
628 VK_BLEND_FACTOR_SRC_COLOR = 2, | |
629 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, | |
630 VK_BLEND_FACTOR_DST_COLOR = 4, | |
631 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, | |
632 VK_BLEND_FACTOR_SRC_ALPHA = 6, | |
633 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, | |
634 VK_BLEND_FACTOR_DST_ALPHA = 8, | |
635 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, | |
636 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, | |
637 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, | |
638 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, | |
639 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, | |
640 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, | |
641 VK_BLEND_FACTOR_SRC1_COLOR = 15, | |
642 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, | |
643 VK_BLEND_FACTOR_SRC1_ALPHA = 17, | |
644 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, | |
645 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, | |
646 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, | |
647 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEN
D_FACTOR_ZERO + 1), | |
648 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF | |
649 } VkBlendFactor; | |
650 | |
651 typedef enum VkBlendOp { | |
652 VK_BLEND_OP_ADD = 0, | |
653 VK_BLEND_OP_SUBTRACT = 1, | |
654 VK_BLEND_OP_REVERSE_SUBTRACT = 2, | |
655 VK_BLEND_OP_MIN = 3, | |
656 VK_BLEND_OP_MAX = 4, | |
657 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, | |
658 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, | |
659 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), | |
660 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF | |
661 } VkBlendOp; | |
662 | |
663 typedef enum VkDynamicState { | |
664 VK_DYNAMIC_STATE_VIEWPORT = 0, | |
665 VK_DYNAMIC_STATE_SCISSOR = 1, | |
666 VK_DYNAMIC_STATE_LINE_WIDTH = 2, | |
667 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, | |
668 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, | |
669 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, | |
670 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, | |
671 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, | |
672 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, | |
673 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, | |
674 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, | |
675 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAM
IC_STATE_VIEWPORT + 1), | |
676 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF | |
677 } VkDynamicState; | |
678 | |
679 typedef enum VkFilter { | |
680 VK_FILTER_NEAREST = 0, | |
681 VK_FILTER_LINEAR = 1, | |
682 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, | |
683 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, | |
684 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), | |
685 VK_FILTER_MAX_ENUM = 0x7FFFFFFF | |
686 } VkFilter; | |
687 | |
688 typedef enum VkSamplerMipmapMode { | |
689 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, | |
690 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, | |
691 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, | |
692 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, | |
693 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMP
LER_MIPMAP_MODE_NEAREST + 1), | |
694 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF | |
695 } VkSamplerMipmapMode; | |
696 | |
697 typedef enum VkSamplerAddressMode { | |
698 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, | |
699 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, | |
700 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, | |
701 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, | |
702 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, | |
703 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, | |
704 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_
EDGE, | |
705 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_T
O_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), | |
706 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF | |
707 } VkSamplerAddressMode; | |
708 | |
709 typedef enum VkBorderColor { | |
710 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, | |
711 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, | |
712 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, | |
713 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, | |
714 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, | |
715 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, | |
716 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, | |
717 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, | |
718 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_C
OLOR_FLOAT_TRANSPARENT_BLACK + 1), | |
719 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF | |
720 } VkBorderColor; | |
721 | |
722 typedef enum VkDescriptorType { | |
723 VK_DESCRIPTOR_TYPE_SAMPLER = 0, | |
724 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, | |
725 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, | |
726 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, | |
727 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, | |
728 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, | |
729 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, | |
730 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, | |
731 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, | |
732 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, | |
733 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, | |
734 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, | |
735 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, | |
736 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DE
SCRIPTOR_TYPE_SAMPLER + 1), | |
737 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF | |
738 } VkDescriptorType; | |
739 | |
740 typedef enum VkAttachmentLoadOp { | |
741 VK_ATTACHMENT_LOAD_OP_LOAD = 0, | |
742 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, | |
743 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, | |
744 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, | |
745 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, | |
746 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATT
ACHMENT_LOAD_OP_LOAD + 1), | |
747 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF | |
748 } VkAttachmentLoadOp; | |
749 | |
750 typedef enum VkAttachmentStoreOp { | |
751 VK_ATTACHMENT_STORE_OP_STORE = 0, | |
752 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, | |
753 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, | |
754 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, | |
755 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_A
TTACHMENT_STORE_OP_STORE + 1), | |
756 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF | |
757 } VkAttachmentStoreOp; | |
758 | |
759 typedef enum VkPipelineBindPoint { | |
760 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, | |
761 VK_PIPELINE_BIND_POINT_COMPUTE = 1, | |
762 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, | |
763 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, | |
764 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIP
ELINE_BIND_POINT_GRAPHICS + 1), | |
765 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF | |
766 } VkPipelineBindPoint; | |
767 | |
768 typedef enum VkCommandBufferLevel { | |
769 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, | |
770 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, | |
771 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, | |
772 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, | |
773 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK
_COMMAND_BUFFER_LEVEL_PRIMARY + 1), | |
774 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF | |
775 } VkCommandBufferLevel; | |
776 | |
777 typedef enum VkIndexType { | |
778 VK_INDEX_TYPE_UINT16 = 0, | |
779 VK_INDEX_TYPE_UINT32 = 1, | |
780 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, | |
781 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, | |
782 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1)
, | |
783 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF | |
784 } VkIndexType; | |
785 | |
786 typedef enum VkSubpassContents { | |
787 VK_SUBPASS_CONTENTS_INLINE = 0, | |
788 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, | |
789 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, | |
790 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFER
S, | |
791 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFF
ERS - VK_SUBPASS_CONTENTS_INLINE + 1), | |
792 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF | |
793 } VkSubpassContents; | |
794 | |
795 typedef VkFlags VkInstanceCreateFlags; | |
796 | |
797 typedef enum VkFormatFeatureFlagBits { | |
798 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, | |
799 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, | |
800 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, | |
801 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, | |
802 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, | |
803 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, | |
804 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, | |
805 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, | |
806 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, | |
807 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, | |
808 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, | |
809 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, | |
810 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, | |
811 } VkFormatFeatureFlagBits; | |
812 typedef VkFlags VkFormatFeatureFlags; | |
813 | |
814 typedef enum VkImageUsageFlagBits { | |
815 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, | |
816 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, | |
817 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, | |
818 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, | |
819 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, | |
820 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, | |
821 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, | |
822 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, | |
823 } VkImageUsageFlagBits; | |
824 typedef VkFlags VkImageUsageFlags; | |
825 | |
826 typedef enum VkImageCreateFlagBits { | |
827 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, | |
828 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, | |
829 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, | |
830 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, | |
831 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, | |
832 } VkImageCreateFlagBits; | |
833 typedef VkFlags VkImageCreateFlags; | |
834 | |
835 typedef enum VkSampleCountFlagBits { | |
836 VK_SAMPLE_COUNT_1_BIT = 0x00000001, | |
837 VK_SAMPLE_COUNT_2_BIT = 0x00000002, | |
838 VK_SAMPLE_COUNT_4_BIT = 0x00000004, | |
839 VK_SAMPLE_COUNT_8_BIT = 0x00000008, | |
840 VK_SAMPLE_COUNT_16_BIT = 0x00000010, | |
841 VK_SAMPLE_COUNT_32_BIT = 0x00000020, | |
842 VK_SAMPLE_COUNT_64_BIT = 0x00000040, | |
843 } VkSampleCountFlagBits; | |
844 typedef VkFlags VkSampleCountFlags; | |
845 | |
846 typedef enum VkQueueFlagBits { | |
847 VK_QUEUE_GRAPHICS_BIT = 0x00000001, | |
848 VK_QUEUE_COMPUTE_BIT = 0x00000002, | |
849 VK_QUEUE_TRANSFER_BIT = 0x00000004, | |
850 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, | |
851 } VkQueueFlagBits; | |
852 typedef VkFlags VkQueueFlags; | |
853 | |
854 typedef enum VkMemoryPropertyFlagBits { | |
855 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, | |
856 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, | |
857 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, | |
858 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, | |
859 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, | |
860 } VkMemoryPropertyFlagBits; | |
861 typedef VkFlags VkMemoryPropertyFlags; | |
862 | |
863 typedef enum VkMemoryHeapFlagBits { | |
864 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, | |
865 } VkMemoryHeapFlagBits; | |
866 typedef VkFlags VkMemoryHeapFlags; | |
867 typedef VkFlags VkDeviceCreateFlags; | |
868 typedef VkFlags VkDeviceQueueCreateFlags; | |
869 | |
870 typedef enum VkPipelineStageFlagBits { | |
871 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, | |
872 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, | |
873 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, | |
874 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, | |
875 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, | |
876 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, | |
877 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, | |
878 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, | |
879 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, | |
880 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, | |
881 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, | |
882 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, | |
883 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, | |
884 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, | |
885 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, | |
886 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, | |
887 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, | |
888 } VkPipelineStageFlagBits; | |
889 typedef VkFlags VkPipelineStageFlags; | |
890 typedef VkFlags VkMemoryMapFlags; | |
891 | |
892 typedef enum VkImageAspectFlagBits { | |
893 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, | |
894 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, | |
895 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, | |
896 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, | |
897 } VkImageAspectFlagBits; | |
898 typedef VkFlags VkImageAspectFlags; | |
899 | |
900 typedef enum VkSparseImageFormatFlagBits { | |
901 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, | |
902 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, | |
903 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, | |
904 } VkSparseImageFormatFlagBits; | |
905 typedef VkFlags VkSparseImageFormatFlags; | |
906 | |
907 typedef enum VkSparseMemoryBindFlagBits { | |
908 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, | |
909 } VkSparseMemoryBindFlagBits; | |
910 typedef VkFlags VkSparseMemoryBindFlags; | |
911 | |
912 typedef enum VkFenceCreateFlagBits { | |
913 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, | |
914 } VkFenceCreateFlagBits; | |
915 typedef VkFlags VkFenceCreateFlags; | |
916 typedef VkFlags VkSemaphoreCreateFlags; | |
917 typedef VkFlags VkEventCreateFlags; | |
918 typedef VkFlags VkQueryPoolCreateFlags; | |
919 | |
920 typedef enum VkQueryPipelineStatisticFlagBits { | |
921 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, | |
922 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, | |
923 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, | |
924 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, | |
925 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, | |
926 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, | |
927 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, | |
928 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, | |
929 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x0000
0100, | |
930 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT =
0x00000200, | |
931 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, | |
932 } VkQueryPipelineStatisticFlagBits; | |
933 typedef VkFlags VkQueryPipelineStatisticFlags; | |
934 | |
935 typedef enum VkQueryResultFlagBits { | |
936 VK_QUERY_RESULT_64_BIT = 0x00000001, | |
937 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, | |
938 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, | |
939 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, | |
940 } VkQueryResultFlagBits; | |
941 typedef VkFlags VkQueryResultFlags; | |
942 | |
943 typedef enum VkBufferCreateFlagBits { | |
944 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, | |
945 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, | |
946 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, | |
947 } VkBufferCreateFlagBits; | |
948 typedef VkFlags VkBufferCreateFlags; | |
949 | |
950 typedef enum VkBufferUsageFlagBits { | |
951 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, | |
952 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, | |
953 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, | |
954 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, | |
955 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, | |
956 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, | |
957 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, | |
958 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, | |
959 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, | |
960 } VkBufferUsageFlagBits; | |
961 typedef VkFlags VkBufferUsageFlags; | |
962 typedef VkFlags VkBufferViewCreateFlags; | |
963 typedef VkFlags VkImageViewCreateFlags; | |
964 typedef VkFlags VkShaderModuleCreateFlags; | |
965 typedef VkFlags VkPipelineCacheCreateFlags; | |
966 | |
967 typedef enum VkPipelineCreateFlagBits { | |
968 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, | |
969 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, | |
970 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, | |
971 } VkPipelineCreateFlagBits; | |
972 typedef VkFlags VkPipelineCreateFlags; | |
973 typedef VkFlags VkPipelineShaderStageCreateFlags; | |
974 | |
975 typedef enum VkShaderStageFlagBits { | |
976 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, | |
977 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, | |
978 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, | |
979 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, | |
980 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, | |
981 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, | |
982 VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, | |
983 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, | |
984 } VkShaderStageFlagBits; | |
985 typedef VkFlags VkPipelineVertexInputStateCreateFlags; | |
986 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; | |
987 typedef VkFlags VkPipelineTessellationStateCreateFlags; | |
988 typedef VkFlags VkPipelineViewportStateCreateFlags; | |
989 typedef VkFlags VkPipelineRasterizationStateCreateFlags; | |
990 | |
991 typedef enum VkCullModeFlagBits { | |
992 VK_CULL_MODE_NONE = 0, | |
993 VK_CULL_MODE_FRONT_BIT = 0x00000001, | |
994 VK_CULL_MODE_BACK_BIT = 0x00000002, | |
995 VK_CULL_MODE_FRONT_AND_BACK = 0x3, | |
996 } VkCullModeFlagBits; | |
997 typedef VkFlags VkCullModeFlags; | |
998 typedef VkFlags VkPipelineMultisampleStateCreateFlags; | |
999 typedef VkFlags VkPipelineDepthStencilStateCreateFlags; | |
1000 typedef VkFlags VkPipelineColorBlendStateCreateFlags; | |
1001 | |
1002 typedef enum VkColorComponentFlagBits { | |
1003 VK_COLOR_COMPONENT_R_BIT = 0x00000001, | |
1004 VK_COLOR_COMPONENT_G_BIT = 0x00000002, | |
1005 VK_COLOR_COMPONENT_B_BIT = 0x00000004, | |
1006 VK_COLOR_COMPONENT_A_BIT = 0x00000008, | |
1007 } VkColorComponentFlagBits; | |
1008 typedef VkFlags VkColorComponentFlags; | |
1009 typedef VkFlags VkPipelineDynamicStateCreateFlags; | |
1010 typedef VkFlags VkPipelineLayoutCreateFlags; | |
1011 typedef VkFlags VkShaderStageFlags; | |
1012 typedef VkFlags VkSamplerCreateFlags; | |
1013 typedef VkFlags VkDescriptorSetLayoutCreateFlags; | |
1014 | |
1015 typedef enum VkDescriptorPoolCreateFlagBits { | |
1016 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, | |
1017 } VkDescriptorPoolCreateFlagBits; | |
1018 typedef VkFlags VkDescriptorPoolCreateFlags; | |
1019 typedef VkFlags VkDescriptorPoolResetFlags; | |
1020 typedef VkFlags VkFramebufferCreateFlags; | |
1021 typedef VkFlags VkRenderPassCreateFlags; | |
1022 | |
1023 typedef enum VkAttachmentDescriptionFlagBits { | |
1024 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, | |
1025 } VkAttachmentDescriptionFlagBits; | |
1026 typedef VkFlags VkAttachmentDescriptionFlags; | |
1027 typedef VkFlags VkSubpassDescriptionFlags; | |
1028 | |
1029 typedef enum VkAccessFlagBits { | |
1030 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, | |
1031 VK_ACCESS_INDEX_READ_BIT = 0x00000002, | |
1032 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, | |
1033 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, | |
1034 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, | |
1035 VK_ACCESS_SHADER_READ_BIT = 0x00000020, | |
1036 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, | |
1037 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, | |
1038 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, | |
1039 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, | |
1040 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, | |
1041 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, | |
1042 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, | |
1043 VK_ACCESS_HOST_READ_BIT = 0x00002000, | |
1044 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, | |
1045 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, | |
1046 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, | |
1047 } VkAccessFlagBits; | |
1048 typedef VkFlags VkAccessFlags; | |
1049 | |
1050 typedef enum VkDependencyFlagBits { | |
1051 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, | |
1052 } VkDependencyFlagBits; | |
1053 typedef VkFlags VkDependencyFlags; | |
1054 | |
1055 typedef enum VkCommandPoolCreateFlagBits { | |
1056 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, | |
1057 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, | |
1058 } VkCommandPoolCreateFlagBits; | |
1059 typedef VkFlags VkCommandPoolCreateFlags; | |
1060 | |
1061 typedef enum VkCommandPoolResetFlagBits { | |
1062 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, | |
1063 } VkCommandPoolResetFlagBits; | |
1064 typedef VkFlags VkCommandPoolResetFlags; | |
1065 | |
1066 typedef enum VkCommandBufferUsageFlagBits { | |
1067 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, | |
1068 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, | |
1069 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, | |
1070 } VkCommandBufferUsageFlagBits; | |
1071 typedef VkFlags VkCommandBufferUsageFlags; | |
1072 | |
1073 typedef enum VkQueryControlFlagBits { | |
1074 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, | |
1075 } VkQueryControlFlagBits; | |
1076 typedef VkFlags VkQueryControlFlags; | |
1077 | |
1078 typedef enum VkCommandBufferResetFlagBits { | |
1079 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, | |
1080 } VkCommandBufferResetFlagBits; | |
1081 typedef VkFlags VkCommandBufferResetFlags; | |
1082 | |
1083 typedef enum VkStencilFaceFlagBits { | |
1084 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, | |
1085 VK_STENCIL_FACE_BACK_BIT = 0x00000002, | |
1086 VK_STENCIL_FRONT_AND_BACK = 0x3, | |
1087 } VkStencilFaceFlagBits; | |
1088 typedef VkFlags VkStencilFaceFlags; | |
1089 | |
1090 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( | |
1091 void* pUserData, | |
1092 size_t size, | |
1093 size_t alignment, | |
1094 VkSystemAllocationScope allocationScope); | |
1095 | |
1096 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( | |
1097 void* pUserData, | |
1098 void* pOriginal, | |
1099 size_t size, | |
1100 size_t alignment, | |
1101 VkSystemAllocationScope allocationScope); | |
1102 | |
1103 typedef void (VKAPI_PTR *PFN_vkFreeFunction)( | |
1104 void* pUserData, | |
1105 void* pMemory); | |
1106 | |
1107 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( | |
1108 void* pUserData, | |
1109 size_t size, | |
1110 VkInternalAllocationType allocationType, | |
1111 VkSystemAllocationScope allocationScope); | |
1112 | |
1113 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( | |
1114 void* pUserData, | |
1115 size_t size, | |
1116 VkInternalAllocationType allocationType, | |
1117 VkSystemAllocationScope allocationScope); | |
1118 | |
1119 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); | |
1120 | |
1121 typedef struct VkApplicationInfo { | |
1122 VkStructureType sType; | |
1123 const void* pNext; | |
1124 const char* pApplicationName; | |
1125 uint32_t applicationVersion; | |
1126 const char* pEngineName; | |
1127 uint32_t engineVersion; | |
1128 uint32_t apiVersion; | |
1129 } VkApplicationInfo; | |
1130 | |
1131 typedef struct VkInstanceCreateInfo { | |
1132 VkStructureType sType; | |
1133 const void* pNext; | |
1134 VkInstanceCreateFlags flags; | |
1135 const VkApplicationInfo* pApplicationInfo; | |
1136 uint32_t enabledLayerCount; | |
1137 const char* const* ppEnabledLayerNames; | |
1138 uint32_t enabledExtensionCount; | |
1139 const char* const* ppEnabledExtensionNames; | |
1140 } VkInstanceCreateInfo; | |
1141 | |
1142 typedef struct VkAllocationCallbacks { | |
1143 void* pUserData; | |
1144 PFN_vkAllocationFunction pfnAllocation; | |
1145 PFN_vkReallocationFunction pfnReallocation; | |
1146 PFN_vkFreeFunction pfnFree; | |
1147 PFN_vkInternalAllocationNotification pfnInternalAllocation; | |
1148 PFN_vkInternalFreeNotification pfnInternalFree; | |
1149 } VkAllocationCallbacks; | |
1150 | |
1151 typedef struct VkPhysicalDeviceFeatures { | |
1152 VkBool32 robustBufferAccess; | |
1153 VkBool32 fullDrawIndexUint32; | |
1154 VkBool32 imageCubeArray; | |
1155 VkBool32 independentBlend; | |
1156 VkBool32 geometryShader; | |
1157 VkBool32 tessellationShader; | |
1158 VkBool32 sampleRateShading; | |
1159 VkBool32 dualSrcBlend; | |
1160 VkBool32 logicOp; | |
1161 VkBool32 multiDrawIndirect; | |
1162 VkBool32 drawIndirectFirstInstance; | |
1163 VkBool32 depthClamp; | |
1164 VkBool32 depthBiasClamp; | |
1165 VkBool32 fillModeNonSolid; | |
1166 VkBool32 depthBounds; | |
1167 VkBool32 wideLines; | |
1168 VkBool32 largePoints; | |
1169 VkBool32 alphaToOne; | |
1170 VkBool32 multiViewport; | |
1171 VkBool32 samplerAnisotropy; | |
1172 VkBool32 textureCompressionETC2; | |
1173 VkBool32 textureCompressionASTC_LDR; | |
1174 VkBool32 textureCompressionBC; | |
1175 VkBool32 occlusionQueryPrecise; | |
1176 VkBool32 pipelineStatisticsQuery; | |
1177 VkBool32 vertexPipelineStoresAndAtomics; | |
1178 VkBool32 fragmentStoresAndAtomics; | |
1179 VkBool32 shaderTessellationAndGeometryPointSize; | |
1180 VkBool32 shaderImageGatherExtended; | |
1181 VkBool32 shaderStorageImageExtendedFormats; | |
1182 VkBool32 shaderStorageImageMultisample; | |
1183 VkBool32 shaderStorageImageReadWithoutFormat; | |
1184 VkBool32 shaderStorageImageWriteWithoutFormat; | |
1185 VkBool32 shaderUniformBufferArrayDynamicIndexing; | |
1186 VkBool32 shaderSampledImageArrayDynamicIndexing; | |
1187 VkBool32 shaderStorageBufferArrayDynamicIndexing; | |
1188 VkBool32 shaderStorageImageArrayDynamicIndexing; | |
1189 VkBool32 shaderClipDistance; | |
1190 VkBool32 shaderCullDistance; | |
1191 VkBool32 shaderFloat64; | |
1192 VkBool32 shaderInt64; | |
1193 VkBool32 shaderInt16; | |
1194 VkBool32 shaderResourceResidency; | |
1195 VkBool32 shaderResourceMinLod; | |
1196 VkBool32 sparseBinding; | |
1197 VkBool32 sparseResidencyBuffer; | |
1198 VkBool32 sparseResidencyImage2D; | |
1199 VkBool32 sparseResidencyImage3D; | |
1200 VkBool32 sparseResidency2Samples; | |
1201 VkBool32 sparseResidency4Samples; | |
1202 VkBool32 sparseResidency8Samples; | |
1203 VkBool32 sparseResidency16Samples; | |
1204 VkBool32 sparseResidencyAliased; | |
1205 VkBool32 variableMultisampleRate; | |
1206 VkBool32 inheritedQueries; | |
1207 } VkPhysicalDeviceFeatures; | |
1208 | |
1209 typedef struct VkFormatProperties { | |
1210 VkFormatFeatureFlags linearTilingFeatures; | |
1211 VkFormatFeatureFlags optimalTilingFeatures; | |
1212 VkFormatFeatureFlags bufferFeatures; | |
1213 } VkFormatProperties; | |
1214 | |
1215 typedef struct VkExtent3D { | |
1216 uint32_t width; | |
1217 uint32_t height; | |
1218 uint32_t depth; | |
1219 } VkExtent3D; | |
1220 | |
1221 typedef struct VkImageFormatProperties { | |
1222 VkExtent3D maxExtent; | |
1223 uint32_t maxMipLevels; | |
1224 uint32_t maxArrayLayers; | |
1225 VkSampleCountFlags sampleCounts; | |
1226 VkDeviceSize maxResourceSize; | |
1227 } VkImageFormatProperties; | |
1228 | |
1229 typedef struct VkPhysicalDeviceLimits { | |
1230 uint32_t maxImageDimension1D; | |
1231 uint32_t maxImageDimension2D; | |
1232 uint32_t maxImageDimension3D; | |
1233 uint32_t maxImageDimensionCube; | |
1234 uint32_t maxImageArrayLayers; | |
1235 uint32_t maxTexelBufferElements; | |
1236 uint32_t maxUniformBufferRange; | |
1237 uint32_t maxStorageBufferRange; | |
1238 uint32_t maxPushConstantsSize; | |
1239 uint32_t maxMemoryAllocationCount; | |
1240 uint32_t maxSamplerAllocationCount; | |
1241 VkDeviceSize bufferImageGranularity; | |
1242 VkDeviceSize sparseAddressSpaceSize; | |
1243 uint32_t maxBoundDescriptorSets; | |
1244 uint32_t maxPerStageDescriptorSamplers; | |
1245 uint32_t maxPerStageDescriptorUniformBuffers; | |
1246 uint32_t maxPerStageDescriptorStorageBuffers; | |
1247 uint32_t maxPerStageDescriptorSampledImages; | |
1248 uint32_t maxPerStageDescriptorStorageImages; | |
1249 uint32_t maxPerStageDescriptorInputAttachments; | |
1250 uint32_t maxPerStageResources; | |
1251 uint32_t maxDescriptorSetSamplers; | |
1252 uint32_t maxDescriptorSetUniformBuffers; | |
1253 uint32_t maxDescriptorSetUniformBuffersDynamic; | |
1254 uint32_t maxDescriptorSetStorageBuffers; | |
1255 uint32_t maxDescriptorSetStorageBuffersDynamic; | |
1256 uint32_t maxDescriptorSetSampledImages; | |
1257 uint32_t maxDescriptorSetStorageImages; | |
1258 uint32_t maxDescriptorSetInputAttachments; | |
1259 uint32_t maxVertexInputAttributes; | |
1260 uint32_t maxVertexInputBindings; | |
1261 uint32_t maxVertexInputAttributeOffset; | |
1262 uint32_t maxVertexInputBindingStride; | |
1263 uint32_t maxVertexOutputComponents; | |
1264 uint32_t maxTessellationGenerationLevel; | |
1265 uint32_t maxTessellationPatchSize; | |
1266 uint32_t maxTessellationControlPerVertexInputComponents; | |
1267 uint32_t maxTessellationControlPerVertexOutputComponents; | |
1268 uint32_t maxTessellationControlPerPatchOutputComponents; | |
1269 uint32_t maxTessellationControlTotalOutputComponents; | |
1270 uint32_t maxTessellationEvaluationInputComponents; | |
1271 uint32_t maxTessellationEvaluationOutputComponents; | |
1272 uint32_t maxGeometryShaderInvocations; | |
1273 uint32_t maxGeometryInputComponents; | |
1274 uint32_t maxGeometryOutputComponents; | |
1275 uint32_t maxGeometryOutputVertices; | |
1276 uint32_t maxGeometryTotalOutputComponents; | |
1277 uint32_t maxFragmentInputComponents; | |
1278 uint32_t maxFragmentOutputAttachments; | |
1279 uint32_t maxFragmentDualSrcAttachments; | |
1280 uint32_t maxFragmentCombinedOutputResources; | |
1281 uint32_t maxComputeSharedMemorySize; | |
1282 uint32_t maxComputeWorkGroupCount[3]; | |
1283 uint32_t maxComputeWorkGroupInvocations; | |
1284 uint32_t maxComputeWorkGroupSize[3]; | |
1285 uint32_t subPixelPrecisionBits; | |
1286 uint32_t subTexelPrecisionBits; | |
1287 uint32_t mipmapPrecisionBits; | |
1288 uint32_t maxDrawIndexedIndexValue; | |
1289 uint32_t maxDrawIndirectCount; | |
1290 float maxSamplerLodBias; | |
1291 float maxSamplerAnisotropy; | |
1292 uint32_t maxViewports; | |
1293 uint32_t maxViewportDimensions[2]; | |
1294 float viewportBoundsRange[2]; | |
1295 uint32_t viewportSubPixelBits; | |
1296 size_t minMemoryMapAlignment; | |
1297 VkDeviceSize minTexelBufferOffsetAlignment; | |
1298 VkDeviceSize minUniformBufferOffsetAlignment; | |
1299 VkDeviceSize minStorageBufferOffsetAlignment; | |
1300 int32_t minTexelOffset; | |
1301 uint32_t maxTexelOffset; | |
1302 int32_t minTexelGatherOffset; | |
1303 uint32_t maxTexelGatherOffset; | |
1304 float minInterpolationOffset; | |
1305 float maxInterpolationOffset; | |
1306 uint32_t subPixelInterpolationOffsetBits; | |
1307 uint32_t maxFramebufferWidth; | |
1308 uint32_t maxFramebufferHeight; | |
1309 uint32_t maxFramebufferLayers; | |
1310 VkSampleCountFlags framebufferColorSampleCounts; | |
1311 VkSampleCountFlags framebufferDepthSampleCounts; | |
1312 VkSampleCountFlags framebufferStencilSampleCounts; | |
1313 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; | |
1314 uint32_t maxColorAttachments; | |
1315 VkSampleCountFlags sampledImageColorSampleCounts; | |
1316 VkSampleCountFlags sampledImageIntegerSampleCounts; | |
1317 VkSampleCountFlags sampledImageDepthSampleCounts; | |
1318 VkSampleCountFlags sampledImageStencilSampleCounts; | |
1319 VkSampleCountFlags storageImageSampleCounts; | |
1320 uint32_t maxSampleMaskWords; | |
1321 VkBool32 timestampComputeAndGraphics; | |
1322 float timestampPeriod; | |
1323 uint32_t maxClipDistances; | |
1324 uint32_t maxCullDistances; | |
1325 uint32_t maxCombinedClipAndCullDistances; | |
1326 uint32_t discreteQueuePriorities; | |
1327 float pointSizeRange[2]; | |
1328 float lineWidthRange[2]; | |
1329 float pointSizeGranularity; | |
1330 float lineWidthGranularity; | |
1331 VkBool32 strictLines; | |
1332 VkBool32 standardSampleLocations; | |
1333 VkDeviceSize optimalBufferCopyOffsetAlignment; | |
1334 VkDeviceSize optimalBufferCopyRowPitchAlignment; | |
1335 VkDeviceSize nonCoherentAtomSize; | |
1336 } VkPhysicalDeviceLimits; | |
1337 | |
1338 typedef struct VkPhysicalDeviceSparseProperties { | |
1339 VkBool32 residencyStandard2DBlockShape; | |
1340 VkBool32 residencyStandard2DMultisampleBlockShape; | |
1341 VkBool32 residencyStandard3DBlockShape; | |
1342 VkBool32 residencyAlignedMipSize; | |
1343 VkBool32 residencyNonResidentStrict; | |
1344 } VkPhysicalDeviceSparseProperties; | |
1345 | |
1346 typedef struct VkPhysicalDeviceProperties { | |
1347 uint32_t apiVersion; | |
1348 uint32_t driverVersion; | |
1349 uint32_t vendorID; | |
1350 uint32_t deviceID; | |
1351 VkPhysicalDeviceType deviceType; | |
1352 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_S
IZE]; | |
1353 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; | |
1354 VkPhysicalDeviceLimits limits; | |
1355 VkPhysicalDeviceSparseProperties sparseProperties; | |
1356 } VkPhysicalDeviceProperties; | |
1357 | |
1358 typedef struct VkQueueFamilyProperties { | |
1359 VkQueueFlags queueFlags; | |
1360 uint32_t queueCount; | |
1361 uint32_t timestampValidBits; | |
1362 VkExtent3D minImageTransferGranularity; | |
1363 } VkQueueFamilyProperties; | |
1364 | |
1365 typedef struct VkMemoryType { | |
1366 VkMemoryPropertyFlags propertyFlags; | |
1367 uint32_t heapIndex; | |
1368 } VkMemoryType; | |
1369 | |
1370 typedef struct VkMemoryHeap { | |
1371 VkDeviceSize size; | |
1372 VkMemoryHeapFlags flags; | |
1373 } VkMemoryHeap; | |
1374 | |
1375 typedef struct VkPhysicalDeviceMemoryProperties { | |
1376 uint32_t memoryTypeCount; | |
1377 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; | |
1378 uint32_t memoryHeapCount; | |
1379 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; | |
1380 } VkPhysicalDeviceMemoryProperties; | |
1381 | |
1382 typedef struct VkDeviceQueueCreateInfo { | |
1383 VkStructureType sType; | |
1384 const void* pNext; | |
1385 VkDeviceQueueCreateFlags flags; | |
1386 uint32_t queueFamilyIndex; | |
1387 uint32_t queueCount; | |
1388 const float* pQueuePriorities; | |
1389 } VkDeviceQueueCreateInfo; | |
1390 | |
1391 typedef struct VkDeviceCreateInfo { | |
1392 VkStructureType sType; | |
1393 const void* pNext; | |
1394 VkDeviceCreateFlags flags; | |
1395 uint32_t queueCreateInfoCount; | |
1396 const VkDeviceQueueCreateInfo* pQueueCreateInfos; | |
1397 uint32_t enabledLayerCount; | |
1398 const char* const* ppEnabledLayerNames; | |
1399 uint32_t enabledExtensionCount; | |
1400 const char* const* ppEnabledExtensionNames; | |
1401 const VkPhysicalDeviceFeatures* pEnabledFeatures; | |
1402 } VkDeviceCreateInfo; | |
1403 | |
1404 typedef struct VkExtensionProperties { | |
1405 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; | |
1406 uint32_t specVersion; | |
1407 } VkExtensionProperties; | |
1408 | |
1409 typedef struct VkLayerProperties { | |
1410 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; | |
1411 uint32_t specVersion; | |
1412 uint32_t implementationVersion; | |
1413 char description[VK_MAX_DESCRIPTION_SIZE]; | |
1414 } VkLayerProperties; | |
1415 | |
1416 typedef struct VkSubmitInfo { | |
1417 VkStructureType sType; | |
1418 const void* pNext; | |
1419 uint32_t waitSemaphoreCount; | |
1420 const VkSemaphore* pWaitSemaphores; | |
1421 const VkPipelineStageFlags* pWaitDstStageMask; | |
1422 uint32_t commandBufferCount; | |
1423 const VkCommandBuffer* pCommandBuffers; | |
1424 uint32_t signalSemaphoreCount; | |
1425 const VkSemaphore* pSignalSemaphores; | |
1426 } VkSubmitInfo; | |
1427 | |
1428 typedef struct VkMemoryAllocateInfo { | |
1429 VkStructureType sType; | |
1430 const void* pNext; | |
1431 VkDeviceSize allocationSize; | |
1432 uint32_t memoryTypeIndex; | |
1433 } VkMemoryAllocateInfo; | |
1434 | |
1435 typedef struct VkMappedMemoryRange { | |
1436 VkStructureType sType; | |
1437 const void* pNext; | |
1438 VkDeviceMemory memory; | |
1439 VkDeviceSize offset; | |
1440 VkDeviceSize size; | |
1441 } VkMappedMemoryRange; | |
1442 | |
1443 typedef struct VkMemoryRequirements { | |
1444 VkDeviceSize size; | |
1445 VkDeviceSize alignment; | |
1446 uint32_t memoryTypeBits; | |
1447 } VkMemoryRequirements; | |
1448 | |
1449 typedef struct VkSparseImageFormatProperties { | |
1450 VkImageAspectFlags aspectMask; | |
1451 VkExtent3D imageGranularity; | |
1452 VkSparseImageFormatFlags flags; | |
1453 } VkSparseImageFormatProperties; | |
1454 | |
1455 typedef struct VkSparseImageMemoryRequirements { | |
1456 VkSparseImageFormatProperties formatProperties; | |
1457 uint32_t imageMipTailFirstLod; | |
1458 VkDeviceSize imageMipTailSize; | |
1459 VkDeviceSize imageMipTailOffset; | |
1460 VkDeviceSize imageMipTailStride; | |
1461 } VkSparseImageMemoryRequirements; | |
1462 | |
1463 typedef struct VkSparseMemoryBind { | |
1464 VkDeviceSize resourceOffset; | |
1465 VkDeviceSize size; | |
1466 VkDeviceMemory memory; | |
1467 VkDeviceSize memoryOffset; | |
1468 VkSparseMemoryBindFlags flags; | |
1469 } VkSparseMemoryBind; | |
1470 | |
1471 typedef struct VkSparseBufferMemoryBindInfo { | |
1472 VkBuffer buffer; | |
1473 uint32_t bindCount; | |
1474 const VkSparseMemoryBind* pBinds; | |
1475 } VkSparseBufferMemoryBindInfo; | |
1476 | |
1477 typedef struct VkSparseImageOpaqueMemoryBindInfo { | |
1478 VkImage image; | |
1479 uint32_t bindCount; | |
1480 const VkSparseMemoryBind* pBinds; | |
1481 } VkSparseImageOpaqueMemoryBindInfo; | |
1482 | |
1483 typedef struct VkImageSubresource { | |
1484 VkImageAspectFlags aspectMask; | |
1485 uint32_t mipLevel; | |
1486 uint32_t arrayLayer; | |
1487 } VkImageSubresource; | |
1488 | |
1489 typedef struct VkOffset3D { | |
1490 int32_t x; | |
1491 int32_t y; | |
1492 int32_t z; | |
1493 } VkOffset3D; | |
1494 | |
1495 typedef struct VkSparseImageMemoryBind { | |
1496 VkImageSubresource subresource; | |
1497 VkOffset3D offset; | |
1498 VkExtent3D extent; | |
1499 VkDeviceMemory memory; | |
1500 VkDeviceSize memoryOffset; | |
1501 VkSparseMemoryBindFlags flags; | |
1502 } VkSparseImageMemoryBind; | |
1503 | |
1504 typedef struct VkSparseImageMemoryBindInfo { | |
1505 VkImage image; | |
1506 uint32_t bindCount; | |
1507 const VkSparseImageMemoryBind* pBinds; | |
1508 } VkSparseImageMemoryBindInfo; | |
1509 | |
1510 typedef struct VkBindSparseInfo { | |
1511 VkStructureType sType; | |
1512 const void* pNext; | |
1513 uint32_t waitSemaphoreCount; | |
1514 const VkSemaphore* pWaitSemaphores; | |
1515 uint32_t bufferBindCount; | |
1516 const VkSparseBufferMemoryBindInfo* pBufferBinds; | |
1517 uint32_t imageOpaqueBindCount; | |
1518 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; | |
1519 uint32_t imageBindCount; | |
1520 const VkSparseImageMemoryBindInfo* pImageBinds; | |
1521 uint32_t signalSemaphoreCount; | |
1522 const VkSemaphore* pSignalSemaphores; | |
1523 } VkBindSparseInfo; | |
1524 | |
1525 typedef struct VkFenceCreateInfo { | |
1526 VkStructureType sType; | |
1527 const void* pNext; | |
1528 VkFenceCreateFlags flags; | |
1529 } VkFenceCreateInfo; | |
1530 | |
1531 typedef struct VkSemaphoreCreateInfo { | |
1532 VkStructureType sType; | |
1533 const void* pNext; | |
1534 VkSemaphoreCreateFlags flags; | |
1535 } VkSemaphoreCreateInfo; | |
1536 | |
1537 typedef struct VkEventCreateInfo { | |
1538 VkStructureType sType; | |
1539 const void* pNext; | |
1540 VkEventCreateFlags flags; | |
1541 } VkEventCreateInfo; | |
1542 | |
1543 typedef struct VkQueryPoolCreateInfo { | |
1544 VkStructureType sType; | |
1545 const void* pNext; | |
1546 VkQueryPoolCreateFlags flags; | |
1547 VkQueryType queryType; | |
1548 uint32_t queryCount; | |
1549 VkQueryPipelineStatisticFlags pipelineStatistics; | |
1550 } VkQueryPoolCreateInfo; | |
1551 | |
1552 typedef struct VkBufferCreateInfo { | |
1553 VkStructureType sType; | |
1554 const void* pNext; | |
1555 VkBufferCreateFlags flags; | |
1556 VkDeviceSize size; | |
1557 VkBufferUsageFlags usage; | |
1558 VkSharingMode sharingMode; | |
1559 uint32_t queueFamilyIndexCount; | |
1560 const uint32_t* pQueueFamilyIndices; | |
1561 } VkBufferCreateInfo; | |
1562 | |
1563 typedef struct VkBufferViewCreateInfo { | |
1564 VkStructureType sType; | |
1565 const void* pNext; | |
1566 VkBufferViewCreateFlags flags; | |
1567 VkBuffer buffer; | |
1568 VkFormat format; | |
1569 VkDeviceSize offset; | |
1570 VkDeviceSize range; | |
1571 } VkBufferViewCreateInfo; | |
1572 | |
1573 typedef struct VkImageCreateInfo { | |
1574 VkStructureType sType; | |
1575 const void* pNext; | |
1576 VkImageCreateFlags flags; | |
1577 VkImageType imageType; | |
1578 VkFormat format; | |
1579 VkExtent3D extent; | |
1580 uint32_t mipLevels; | |
1581 uint32_t arrayLayers; | |
1582 VkSampleCountFlagBits samples; | |
1583 VkImageTiling tiling; | |
1584 VkImageUsageFlags usage; | |
1585 VkSharingMode sharingMode; | |
1586 uint32_t queueFamilyIndexCount; | |
1587 const uint32_t* pQueueFamilyIndices; | |
1588 VkImageLayout initialLayout; | |
1589 } VkImageCreateInfo; | |
1590 | |
1591 typedef struct VkSubresourceLayout { | |
1592 VkDeviceSize offset; | |
1593 VkDeviceSize size; | |
1594 VkDeviceSize rowPitch; | |
1595 VkDeviceSize arrayPitch; | |
1596 VkDeviceSize depthPitch; | |
1597 } VkSubresourceLayout; | |
1598 | |
1599 typedef struct VkComponentMapping { | |
1600 VkComponentSwizzle r; | |
1601 VkComponentSwizzle g; | |
1602 VkComponentSwizzle b; | |
1603 VkComponentSwizzle a; | |
1604 } VkComponentMapping; | |
1605 | |
1606 typedef struct VkImageSubresourceRange { | |
1607 VkImageAspectFlags aspectMask; | |
1608 uint32_t baseMipLevel; | |
1609 uint32_t levelCount; | |
1610 uint32_t baseArrayLayer; | |
1611 uint32_t layerCount; | |
1612 } VkImageSubresourceRange; | |
1613 | |
1614 typedef struct VkImageViewCreateInfo { | |
1615 VkStructureType sType; | |
1616 const void* pNext; | |
1617 VkImageViewCreateFlags flags; | |
1618 VkImage image; | |
1619 VkImageViewType viewType; | |
1620 VkFormat format; | |
1621 VkComponentMapping components; | |
1622 VkImageSubresourceRange subresourceRange; | |
1623 } VkImageViewCreateInfo; | |
1624 | |
1625 typedef struct VkShaderModuleCreateInfo { | |
1626 VkStructureType sType; | |
1627 const void* pNext; | |
1628 VkShaderModuleCreateFlags flags; | |
1629 size_t codeSize; | |
1630 const uint32_t* pCode; | |
1631 } VkShaderModuleCreateInfo; | |
1632 | |
1633 typedef struct VkPipelineCacheCreateInfo { | |
1634 VkStructureType sType; | |
1635 const void* pNext; | |
1636 VkPipelineCacheCreateFlags flags; | |
1637 size_t initialDataSize; | |
1638 const void* pInitialData; | |
1639 } VkPipelineCacheCreateInfo; | |
1640 | |
1641 typedef struct VkSpecializationMapEntry { | |
1642 uint32_t constantID; | |
1643 uint32_t offset; | |
1644 size_t size; | |
1645 } VkSpecializationMapEntry; | |
1646 | |
1647 typedef struct VkSpecializationInfo { | |
1648 uint32_t mapEntryCount; | |
1649 const VkSpecializationMapEntry* pMapEntries; | |
1650 size_t dataSize; | |
1651 const void* pData; | |
1652 } VkSpecializationInfo; | |
1653 | |
1654 typedef struct VkPipelineShaderStageCreateInfo { | |
1655 VkStructureType sType; | |
1656 const void* pNext; | |
1657 VkPipelineShaderStageCreateFlags flags; | |
1658 VkShaderStageFlagBits stage; | |
1659 VkShaderModule module; | |
1660 const char* pName; | |
1661 const VkSpecializationInfo* pSpecializationInfo; | |
1662 } VkPipelineShaderStageCreateInfo; | |
1663 | |
1664 typedef struct VkVertexInputBindingDescription { | |
1665 uint32_t binding; | |
1666 uint32_t stride; | |
1667 VkVertexInputRate inputRate; | |
1668 } VkVertexInputBindingDescription; | |
1669 | |
1670 typedef struct VkVertexInputAttributeDescription { | |
1671 uint32_t location; | |
1672 uint32_t binding; | |
1673 VkFormat format; | |
1674 uint32_t offset; | |
1675 } VkVertexInputAttributeDescription; | |
1676 | |
1677 typedef struct VkPipelineVertexInputStateCreateInfo { | |
1678 VkStructureType sType; | |
1679 const void* pNext; | |
1680 VkPipelineVertexInputStateCreateFlags flags; | |
1681 uint32_t vertexBindingDescriptionCount; | |
1682 const VkVertexInputBindingDescription* pVertexBindingDescriptions; | |
1683 uint32_t vertexAttributeDescriptionCount; | |
1684 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; | |
1685 } VkPipelineVertexInputStateCreateInfo; | |
1686 | |
1687 typedef struct VkPipelineInputAssemblyStateCreateInfo { | |
1688 VkStructureType sType; | |
1689 const void* pNext; | |
1690 VkPipelineInputAssemblyStateCreateFlags flags; | |
1691 VkPrimitiveTopology topology; | |
1692 VkBool32 primitiveRestartEnable; | |
1693 } VkPipelineInputAssemblyStateCreateInfo; | |
1694 | |
1695 typedef struct VkPipelineTessellationStateCreateInfo { | |
1696 VkStructureType sType; | |
1697 const void* pNext; | |
1698 VkPipelineTessellationStateCreateFlags flags; | |
1699 uint32_t patchControlPoints; | |
1700 } VkPipelineTessellationStateCreateInfo; | |
1701 | |
1702 typedef struct VkViewport { | |
1703 float x; | |
1704 float y; | |
1705 float width; | |
1706 float height; | |
1707 float minDepth; | |
1708 float maxDepth; | |
1709 } VkViewport; | |
1710 | |
1711 typedef struct VkOffset2D { | |
1712 int32_t x; | |
1713 int32_t y; | |
1714 } VkOffset2D; | |
1715 | |
1716 typedef struct VkExtent2D { | |
1717 uint32_t width; | |
1718 uint32_t height; | |
1719 } VkExtent2D; | |
1720 | |
1721 typedef struct VkRect2D { | |
1722 VkOffset2D offset; | |
1723 VkExtent2D extent; | |
1724 } VkRect2D; | |
1725 | |
1726 typedef struct VkPipelineViewportStateCreateInfo { | |
1727 VkStructureType sType; | |
1728 const void* pNext; | |
1729 VkPipelineViewportStateCreateFlags flags; | |
1730 uint32_t viewportCount; | |
1731 const VkViewport* pViewports; | |
1732 uint32_t scissorCount; | |
1733 const VkRect2D* pScissors; | |
1734 } VkPipelineViewportStateCreateInfo; | |
1735 | |
1736 typedef struct VkPipelineRasterizationStateCreateInfo { | |
1737 VkStructureType sType; | |
1738 const void* pNext; | |
1739 VkPipelineRasterizationStateCreateFlags flags; | |
1740 VkBool32 depthClampEnable; | |
1741 VkBool32 rasterizerDiscardEnable; | |
1742 VkPolygonMode polygonMode; | |
1743 VkCullModeFlags cullMode; | |
1744 VkFrontFace frontFace; | |
1745 VkBool32 depthBiasEnable; | |
1746 float depthBiasConstantFactor; | |
1747 float depthBiasClamp; | |
1748 float depthBiasSlopeFactor; | |
1749 float lineWidth; | |
1750 } VkPipelineRasterizationStateCreateInfo; | |
1751 | |
1752 typedef struct VkPipelineMultisampleStateCreateInfo { | |
1753 VkStructureType sType; | |
1754 const void* pNext; | |
1755 VkPipelineMultisampleStateCreateFlags flags; | |
1756 VkSampleCountFlagBits rasterizationSamples; | |
1757 VkBool32 sampleShadingEnable; | |
1758 float minSampleShading; | |
1759 const VkSampleMask* pSampleMask; | |
1760 VkBool32 alphaToCoverageEnable; | |
1761 VkBool32 alphaToOneEnable; | |
1762 } VkPipelineMultisampleStateCreateInfo; | |
1763 | |
1764 typedef struct VkStencilOpState { | |
1765 VkStencilOp failOp; | |
1766 VkStencilOp passOp; | |
1767 VkStencilOp depthFailOp; | |
1768 VkCompareOp compareOp; | |
1769 uint32_t compareMask; | |
1770 uint32_t writeMask; | |
1771 uint32_t reference; | |
1772 } VkStencilOpState; | |
1773 | |
1774 typedef struct VkPipelineDepthStencilStateCreateInfo { | |
1775 VkStructureType sType; | |
1776 const void* pNext; | |
1777 VkPipelineDepthStencilStateCreateFlags flags; | |
1778 VkBool32 depthTestEnable; | |
1779 VkBool32 depthWriteEnable; | |
1780 VkCompareOp depthCompareOp; | |
1781 VkBool32 depthBoundsTestEnable; | |
1782 VkBool32 stencilTestEnable; | |
1783 VkStencilOpState front; | |
1784 VkStencilOpState back; | |
1785 float minDepthBounds; | |
1786 float maxDepthBounds; | |
1787 } VkPipelineDepthStencilStateCreateInfo; | |
1788 | |
1789 typedef struct VkPipelineColorBlendAttachmentState { | |
1790 VkBool32 blendEnable; | |
1791 VkBlendFactor srcColorBlendFactor; | |
1792 VkBlendFactor dstColorBlendFactor; | |
1793 VkBlendOp colorBlendOp; | |
1794 VkBlendFactor srcAlphaBlendFactor; | |
1795 VkBlendFactor dstAlphaBlendFactor; | |
1796 VkBlendOp alphaBlendOp; | |
1797 VkColorComponentFlags colorWriteMask; | |
1798 } VkPipelineColorBlendAttachmentState; | |
1799 | |
1800 typedef struct VkPipelineColorBlendStateCreateInfo { | |
1801 VkStructureType sType; | |
1802 const void* pNext; | |
1803 VkPipelineColorBlendStateCreateFlags flags; | |
1804 VkBool32 logicOpEnable; | |
1805 VkLogicOp logicOp; | |
1806 uint32_t attachmentCount; | |
1807 const VkPipelineColorBlendAttachmentState* pAttachments; | |
1808 float blendConstants[4]; | |
1809 } VkPipelineColorBlendStateCreateInfo; | |
1810 | |
1811 typedef struct VkPipelineDynamicStateCreateInfo { | |
1812 VkStructureType sType; | |
1813 const void* pNext; | |
1814 VkPipelineDynamicStateCreateFlags flags; | |
1815 uint32_t dynamicStateCount; | |
1816 const VkDynamicState* pDynamicStates; | |
1817 } VkPipelineDynamicStateCreateInfo; | |
1818 | |
1819 typedef struct VkGraphicsPipelineCreateInfo { | |
1820 VkStructureType sType; | |
1821 const void* pNext; | |
1822 VkPipelineCreateFlags flags; | |
1823 uint32_t stageCount; | |
1824 const VkPipelineShaderStageCreateInfo* pStages; | |
1825 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; | |
1826 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; | |
1827 const VkPipelineTessellationStateCreateInfo* pTessellationState; | |
1828 const VkPipelineViewportStateCreateInfo* pViewportState; | |
1829 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; | |
1830 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; | |
1831 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; | |
1832 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; | |
1833 const VkPipelineDynamicStateCreateInfo* pDynamicState; | |
1834 VkPipelineLayout layout; | |
1835 VkRenderPass renderPass; | |
1836 uint32_t subpass; | |
1837 VkPipeline basePipelineHandle; | |
1838 int32_t basePipelineIndex; | |
1839 } VkGraphicsPipelineCreateInfo; | |
1840 | |
1841 typedef struct VkComputePipelineCreateInfo { | |
1842 VkStructureType sType; | |
1843 const void* pNext; | |
1844 VkPipelineCreateFlags flags; | |
1845 VkPipelineShaderStageCreateInfo stage; | |
1846 VkPipelineLayout layout; | |
1847 VkPipeline basePipelineHandle; | |
1848 int32_t basePipelineIndex; | |
1849 } VkComputePipelineCreateInfo; | |
1850 | |
1851 typedef struct VkPushConstantRange { | |
1852 VkShaderStageFlags stageFlags; | |
1853 uint32_t offset; | |
1854 uint32_t size; | |
1855 } VkPushConstantRange; | |
1856 | |
1857 typedef struct VkPipelineLayoutCreateInfo { | |
1858 VkStructureType sType; | |
1859 const void* pNext; | |
1860 VkPipelineLayoutCreateFlags flags; | |
1861 uint32_t setLayoutCount; | |
1862 const VkDescriptorSetLayout* pSetLayouts; | |
1863 uint32_t pushConstantRangeCount; | |
1864 const VkPushConstantRange* pPushConstantRanges; | |
1865 } VkPipelineLayoutCreateInfo; | |
1866 | |
1867 typedef struct VkSamplerCreateInfo { | |
1868 VkStructureType sType; | |
1869 const void* pNext; | |
1870 VkSamplerCreateFlags flags; | |
1871 VkFilter magFilter; | |
1872 VkFilter minFilter; | |
1873 VkSamplerMipmapMode mipmapMode; | |
1874 VkSamplerAddressMode addressModeU; | |
1875 VkSamplerAddressMode addressModeV; | |
1876 VkSamplerAddressMode addressModeW; | |
1877 float mipLodBias; | |
1878 VkBool32 anisotropyEnable; | |
1879 float maxAnisotropy; | |
1880 VkBool32 compareEnable; | |
1881 VkCompareOp compareOp; | |
1882 float minLod; | |
1883 float maxLod; | |
1884 VkBorderColor borderColor; | |
1885 VkBool32 unnormalizedCoordinates; | |
1886 } VkSamplerCreateInfo; | |
1887 | |
1888 typedef struct VkDescriptorSetLayoutBinding { | |
1889 uint32_t binding; | |
1890 VkDescriptorType descriptorType; | |
1891 uint32_t descriptorCount; | |
1892 VkShaderStageFlags stageFlags; | |
1893 const VkSampler* pImmutableSamplers; | |
1894 } VkDescriptorSetLayoutBinding; | |
1895 | |
1896 typedef struct VkDescriptorSetLayoutCreateInfo { | |
1897 VkStructureType sType; | |
1898 const void* pNext; | |
1899 VkDescriptorSetLayoutCreateFlags flags; | |
1900 uint32_t bindingCount; | |
1901 const VkDescriptorSetLayoutBinding* pBindings; | |
1902 } VkDescriptorSetLayoutCreateInfo; | |
1903 | |
1904 typedef struct VkDescriptorPoolSize { | |
1905 VkDescriptorType type; | |
1906 uint32_t descriptorCount; | |
1907 } VkDescriptorPoolSize; | |
1908 | |
1909 typedef struct VkDescriptorPoolCreateInfo { | |
1910 VkStructureType sType; | |
1911 const void* pNext; | |
1912 VkDescriptorPoolCreateFlags flags; | |
1913 uint32_t maxSets; | |
1914 uint32_t poolSizeCount; | |
1915 const VkDescriptorPoolSize* pPoolSizes; | |
1916 } VkDescriptorPoolCreateInfo; | |
1917 | |
1918 typedef struct VkDescriptorSetAllocateInfo { | |
1919 VkStructureType sType; | |
1920 const void* pNext; | |
1921 VkDescriptorPool descriptorPool; | |
1922 uint32_t descriptorSetCount; | |
1923 const VkDescriptorSetLayout* pSetLayouts; | |
1924 } VkDescriptorSetAllocateInfo; | |
1925 | |
1926 typedef struct VkDescriptorImageInfo { | |
1927 VkSampler sampler; | |
1928 VkImageView imageView; | |
1929 VkImageLayout imageLayout; | |
1930 } VkDescriptorImageInfo; | |
1931 | |
1932 typedef struct VkDescriptorBufferInfo { | |
1933 VkBuffer buffer; | |
1934 VkDeviceSize offset; | |
1935 VkDeviceSize range; | |
1936 } VkDescriptorBufferInfo; | |
1937 | |
1938 typedef struct VkWriteDescriptorSet { | |
1939 VkStructureType sType; | |
1940 const void* pNext; | |
1941 VkDescriptorSet dstSet; | |
1942 uint32_t dstBinding; | |
1943 uint32_t dstArrayElement; | |
1944 uint32_t descriptorCount; | |
1945 VkDescriptorType descriptorType; | |
1946 const VkDescriptorImageInfo* pImageInfo; | |
1947 const VkDescriptorBufferInfo* pBufferInfo; | |
1948 const VkBufferView* pTexelBufferView; | |
1949 } VkWriteDescriptorSet; | |
1950 | |
1951 typedef struct VkCopyDescriptorSet { | |
1952 VkStructureType sType; | |
1953 const void* pNext; | |
1954 VkDescriptorSet srcSet; | |
1955 uint32_t srcBinding; | |
1956 uint32_t srcArrayElement; | |
1957 VkDescriptorSet dstSet; | |
1958 uint32_t dstBinding; | |
1959 uint32_t dstArrayElement; | |
1960 uint32_t descriptorCount; | |
1961 } VkCopyDescriptorSet; | |
1962 | |
1963 typedef struct VkFramebufferCreateInfo { | |
1964 VkStructureType sType; | |
1965 const void* pNext; | |
1966 VkFramebufferCreateFlags flags; | |
1967 VkRenderPass renderPass; | |
1968 uint32_t attachmentCount; | |
1969 const VkImageView* pAttachments; | |
1970 uint32_t width; | |
1971 uint32_t height; | |
1972 uint32_t layers; | |
1973 } VkFramebufferCreateInfo; | |
1974 | |
1975 typedef struct VkAttachmentDescription { | |
1976 VkAttachmentDescriptionFlags flags; | |
1977 VkFormat format; | |
1978 VkSampleCountFlagBits samples; | |
1979 VkAttachmentLoadOp loadOp; | |
1980 VkAttachmentStoreOp storeOp; | |
1981 VkAttachmentLoadOp stencilLoadOp; | |
1982 VkAttachmentStoreOp stencilStoreOp; | |
1983 VkImageLayout initialLayout; | |
1984 VkImageLayout finalLayout; | |
1985 } VkAttachmentDescription; | |
1986 | |
1987 typedef struct VkAttachmentReference { | |
1988 uint32_t attachment; | |
1989 VkImageLayout layout; | |
1990 } VkAttachmentReference; | |
1991 | |
1992 typedef struct VkSubpassDescription { | |
1993 VkSubpassDescriptionFlags flags; | |
1994 VkPipelineBindPoint pipelineBindPoint; | |
1995 uint32_t inputAttachmentCount; | |
1996 const VkAttachmentReference* pInputAttachments; | |
1997 uint32_t colorAttachmentCount; | |
1998 const VkAttachmentReference* pColorAttachments; | |
1999 const VkAttachmentReference* pResolveAttachments; | |
2000 const VkAttachmentReference* pDepthStencilAttachment; | |
2001 uint32_t preserveAttachmentCount; | |
2002 const uint32_t* pPreserveAttachments; | |
2003 } VkSubpassDescription; | |
2004 | |
2005 typedef struct VkSubpassDependency { | |
2006 uint32_t srcSubpass; | |
2007 uint32_t dstSubpass; | |
2008 VkPipelineStageFlags srcStageMask; | |
2009 VkPipelineStageFlags dstStageMask; | |
2010 VkAccessFlags srcAccessMask; | |
2011 VkAccessFlags dstAccessMask; | |
2012 VkDependencyFlags dependencyFlags; | |
2013 } VkSubpassDependency; | |
2014 | |
2015 typedef struct VkRenderPassCreateInfo { | |
2016 VkStructureType sType; | |
2017 const void* pNext; | |
2018 VkRenderPassCreateFlags flags; | |
2019 uint32_t attachmentCount; | |
2020 const VkAttachmentDescription* pAttachments; | |
2021 uint32_t subpassCount; | |
2022 const VkSubpassDescription* pSubpasses; | |
2023 uint32_t dependencyCount; | |
2024 const VkSubpassDependency* pDependencies; | |
2025 } VkRenderPassCreateInfo; | |
2026 | |
2027 typedef struct VkCommandPoolCreateInfo { | |
2028 VkStructureType sType; | |
2029 const void* pNext; | |
2030 VkCommandPoolCreateFlags flags; | |
2031 uint32_t queueFamilyIndex; | |
2032 } VkCommandPoolCreateInfo; | |
2033 | |
2034 typedef struct VkCommandBufferAllocateInfo { | |
2035 VkStructureType sType; | |
2036 const void* pNext; | |
2037 VkCommandPool commandPool; | |
2038 VkCommandBufferLevel level; | |
2039 uint32_t commandBufferCount; | |
2040 } VkCommandBufferAllocateInfo; | |
2041 | |
2042 typedef struct VkCommandBufferInheritanceInfo { | |
2043 VkStructureType sType; | |
2044 const void* pNext; | |
2045 VkRenderPass renderPass; | |
2046 uint32_t subpass; | |
2047 VkFramebuffer framebuffer; | |
2048 VkBool32 occlusionQueryEnable; | |
2049 VkQueryControlFlags queryFlags; | |
2050 VkQueryPipelineStatisticFlags pipelineStatistics; | |
2051 } VkCommandBufferInheritanceInfo; | |
2052 | |
2053 typedef struct VkCommandBufferBeginInfo { | |
2054 VkStructureType sType; | |
2055 const void* pNext; | |
2056 VkCommandBufferUsageFlags flags; | |
2057 const VkCommandBufferInheritanceInfo* pInheritanceInfo; | |
2058 } VkCommandBufferBeginInfo; | |
2059 | |
2060 typedef struct VkBufferCopy { | |
2061 VkDeviceSize srcOffset; | |
2062 VkDeviceSize dstOffset; | |
2063 VkDeviceSize size; | |
2064 } VkBufferCopy; | |
2065 | |
2066 typedef struct VkImageSubresourceLayers { | |
2067 VkImageAspectFlags aspectMask; | |
2068 uint32_t mipLevel; | |
2069 uint32_t baseArrayLayer; | |
2070 uint32_t layerCount; | |
2071 } VkImageSubresourceLayers; | |
2072 | |
2073 typedef struct VkImageCopy { | |
2074 VkImageSubresourceLayers srcSubresource; | |
2075 VkOffset3D srcOffset; | |
2076 VkImageSubresourceLayers dstSubresource; | |
2077 VkOffset3D dstOffset; | |
2078 VkExtent3D extent; | |
2079 } VkImageCopy; | |
2080 | |
2081 typedef struct VkImageBlit { | |
2082 VkImageSubresourceLayers srcSubresource; | |
2083 VkOffset3D srcOffsets[2]; | |
2084 VkImageSubresourceLayers dstSubresource; | |
2085 VkOffset3D dstOffsets[2]; | |
2086 } VkImageBlit; | |
2087 | |
2088 typedef struct VkBufferImageCopy { | |
2089 VkDeviceSize bufferOffset; | |
2090 uint32_t bufferRowLength; | |
2091 uint32_t bufferImageHeight; | |
2092 VkImageSubresourceLayers imageSubresource; | |
2093 VkOffset3D imageOffset; | |
2094 VkExtent3D imageExtent; | |
2095 } VkBufferImageCopy; | |
2096 | |
2097 typedef union VkClearColorValue { | |
2098 float float32[4]; | |
2099 int32_t int32[4]; | |
2100 uint32_t uint32[4]; | |
2101 } VkClearColorValue; | |
2102 | |
2103 typedef struct VkClearDepthStencilValue { | |
2104 float depth; | |
2105 uint32_t stencil; | |
2106 } VkClearDepthStencilValue; | |
2107 | |
2108 typedef union VkClearValue { | |
2109 VkClearColorValue color; | |
2110 VkClearDepthStencilValue depthStencil; | |
2111 } VkClearValue; | |
2112 | |
2113 typedef struct VkClearAttachment { | |
2114 VkImageAspectFlags aspectMask; | |
2115 uint32_t colorAttachment; | |
2116 VkClearValue clearValue; | |
2117 } VkClearAttachment; | |
2118 | |
2119 typedef struct VkClearRect { | |
2120 VkRect2D rect; | |
2121 uint32_t baseArrayLayer; | |
2122 uint32_t layerCount; | |
2123 } VkClearRect; | |
2124 | |
2125 typedef struct VkImageResolve { | |
2126 VkImageSubresourceLayers srcSubresource; | |
2127 VkOffset3D srcOffset; | |
2128 VkImageSubresourceLayers dstSubresource; | |
2129 VkOffset3D dstOffset; | |
2130 VkExtent3D extent; | |
2131 } VkImageResolve; | |
2132 | |
2133 typedef struct VkMemoryBarrier { | |
2134 VkStructureType sType; | |
2135 const void* pNext; | |
2136 VkAccessFlags srcAccessMask; | |
2137 VkAccessFlags dstAccessMask; | |
2138 } VkMemoryBarrier; | |
2139 | |
2140 typedef struct VkBufferMemoryBarrier { | |
2141 VkStructureType sType; | |
2142 const void* pNext; | |
2143 VkAccessFlags srcAccessMask; | |
2144 VkAccessFlags dstAccessMask; | |
2145 uint32_t srcQueueFamilyIndex; | |
2146 uint32_t dstQueueFamilyIndex; | |
2147 VkBuffer buffer; | |
2148 VkDeviceSize offset; | |
2149 VkDeviceSize size; | |
2150 } VkBufferMemoryBarrier; | |
2151 | |
2152 typedef struct VkImageMemoryBarrier { | |
2153 VkStructureType sType; | |
2154 const void* pNext; | |
2155 VkAccessFlags srcAccessMask; | |
2156 VkAccessFlags dstAccessMask; | |
2157 VkImageLayout oldLayout; | |
2158 VkImageLayout newLayout; | |
2159 uint32_t srcQueueFamilyIndex; | |
2160 uint32_t dstQueueFamilyIndex; | |
2161 VkImage image; | |
2162 VkImageSubresourceRange subresourceRange; | |
2163 } VkImageMemoryBarrier; | |
2164 | |
2165 typedef struct VkRenderPassBeginInfo { | |
2166 VkStructureType sType; | |
2167 const void* pNext; | |
2168 VkRenderPass renderPass; | |
2169 VkFramebuffer framebuffer; | |
2170 VkRect2D renderArea; | |
2171 uint32_t clearValueCount; | |
2172 const VkClearValue* pClearValues; | |
2173 } VkRenderPassBeginInfo; | |
2174 | |
2175 typedef struct VkDispatchIndirectCommand { | |
2176 uint32_t x; | |
2177 uint32_t y; | |
2178 uint32_t z; | |
2179 } VkDispatchIndirectCommand; | |
2180 | |
2181 typedef struct VkDrawIndexedIndirectCommand { | |
2182 uint32_t indexCount; | |
2183 uint32_t instanceCount; | |
2184 uint32_t firstIndex; | |
2185 int32_t vertexOffset; | |
2186 uint32_t firstInstance; | |
2187 } VkDrawIndexedIndirectCommand; | |
2188 | |
2189 typedef struct VkDrawIndirectCommand { | |
2190 uint32_t vertexCount; | |
2191 uint32_t instanceCount; | |
2192 uint32_t firstVertex; | |
2193 uint32_t firstInstance; | |
2194 } VkDrawIndirectCommand; | |
2195 | |
2196 | |
2197 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* p
CreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); | |
2198 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAll
ocationCallbacks* pAllocator); | |
2199 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance
, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); | |
2200 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physi
calDevice, VkPhysicalDeviceFeatures* pFeatures); | |
2201 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevi
ce physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); | |
2202 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhy
sicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling til
ing, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties*
pImageFormatProperties); | |
2203 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice phy
sicalDevice, VkPhysicalDeviceProperties* pProperties); | |
2204 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysica
lDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProper
ties* pQueueFamilyProperties); | |
2205 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevi
ce physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); | |
2206 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance ins
tance, const char* pName); | |
2207 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device,
const char* pName); | |
2208 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice
, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkDevice* pDevice); | |
2209 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocatio
nCallbacks* pAllocator); | |
2210 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const c
har* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); | |
2211 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysica
lDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExte
nsionProperties* pProperties); | |
2212 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* p
PropertyCount, VkLayerProperties* pProperties); | |
2213 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDev
ice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); | |
2214 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFa
milyIndex, uint32_t queueIndex, VkQueue* pQueue); | |
2215 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCo
unt, const VkSubmitInfo* pSubmits, VkFence fence); | |
2216 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); | |
2217 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); | |
2218 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemo
ryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDevice
Memory* pMemory); | |
2219 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memor
y, const VkAllocationCallbacks* pAllocator); | |
2220 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory me
mory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppD
ata); | |
2221 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memo
ry); | |
2222 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uin
t32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); | |
2223 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device
, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); | |
2224 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDev
iceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); | |
2225 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer b
uffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); | |
2226 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage ima
ge, VkDeviceMemory memory, VkDeviceSize memoryOffset); | |
2227 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkB
uffer buffer, VkMemoryRequirements* pMemoryRequirements); | |
2228 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkIm
age image, VkMemoryRequirements* pMemoryRequirements); | |
2229 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device
, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryReq
uirements* pSparseMemoryRequirements); | |
2230 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkP
hysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFl
agBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pProper
tyCount, VkSparseImageFormatProperties* pProperties); | |
2231 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bind
InfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); | |
2232 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
; | |
2233 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, con
st VkAllocationCallbacks* pAllocator); | |
2234 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceC
ount, const VkFence* pFences); | |
2235 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fenc
e); | |
2236 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenc
eCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); | |
2237 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSem
aphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaph
ore* pSemaphore); | |
2238 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore se
maphore, const VkAllocationCallbacks* pAllocator); | |
2239 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
; | |
2240 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, con
st VkAllocationCallbacks* pAllocator); | |
2241 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent even
t); | |
2242 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); | |
2243 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); | |
2244 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQue
ryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryP
ool* pQueryPool); | |
2245 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool qu
eryPool, const VkAllocationCallbacks* pAllocator); | |
2246 typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQuery
Pool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void*
pData, VkDeviceSize stride, VkQueryResultFlags flags); | |
2247 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBuffer
CreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuf
fer); | |
2248 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer,
const VkAllocationCallbacks* pAllocator); | |
2249 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBu
fferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuff
erView* pView); | |
2250 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView
bufferView, const VkAllocationCallbacks* pAllocator); | |
2251 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCr
eateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
; | |
2252 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, con
st VkAllocationCallbacks* pAllocator); | |
2253 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkIma
ge image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); | |
2254 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkIma
geViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageV
iew* pView); | |
2255 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView im
ageView, const VkAllocationCallbacks* pAllocator); | |
2256 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const Vk
ShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, Vk
ShaderModule* pShaderModule); | |
2257 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderMod
ule shaderModule, const VkAllocationCallbacks* pAllocator); | |
2258 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const V
kPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache); | |
2259 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipeline
Cache pipelineCache, const VkAllocationCallbacks* pAllocator); | |
2260 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipe
lineCache pipelineCache, size_t* pDataSize, void* pData); | |
2261 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipel
ineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); | |
2262 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkP
ipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCr
eateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPi
pelines); | |
2263 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPi
pelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCrea
teInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipe
lines); | |
2264 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipe
line, const VkAllocationCallbacks* pAllocator); | |
2265 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const
VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkPipelineLayout* pPipelineLayout); | |
2266 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelin
eLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); | |
2267 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSampl
erCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* p
Sampler); | |
2268 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sample
r, const VkAllocationCallbacks* pAllocator); | |
2269 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, c
onst VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkDescriptorSetLayout* pSetLayout); | |
2270 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDe
scriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); | |
2271 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const
VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator
, VkDescriptorPool* pDescriptorPool); | |
2272 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescrip
torPool descriptorPool, const VkAllocationCallbacks* pAllocator); | |
2273 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescr
iptorPool descriptorPool, VkDescriptorPoolResetFlags flags); | |
2274 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, cons
t VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); | |
2275 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescri
ptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDe
scriptorSets); | |
2276 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t d
escriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t des
criptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); | |
2277 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkF
ramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFr
amebuffer* pFramebuffer); | |
2278 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffe
r framebuffer, const VkAllocationCallbacks* pAllocator); | |
2279 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRe
nderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRend
erPass* pRenderPass); | |
2280 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass
renderPass, const VkAllocationCallbacks* pAllocator); | |
2281 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRend
erPass renderPass, VkExtent2D* pGranularity); | |
2282 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkC
ommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCo
mmandPool* pCommandPool); | |
2283 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPoo
l commandPool, const VkAllocationCallbacks* pAllocator); | |
2284 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandP
ool commandPool, VkCommandPoolResetFlags flags); | |
2285 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, cons
t VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); | |
2286 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPoo
l commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffe
rs); | |
2287 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBu
ffer, const VkCommandBufferBeginInfo* pBeginInfo); | |
2288 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuff
er); | |
2289 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBu
ffer, VkCommandBufferResetFlags flags); | |
2290 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, V
kPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); | |
2291 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, ui
nt32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); | |
2292 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uin
t32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); | |
2293 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, f
loat lineWidth); | |
2294 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, f
loat depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); | |
2295 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuff
er, const float blendConstants[4]); | |
2296 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer,
float minDepthBounds, float maxDepthBounds); | |
2297 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer command
Buffer, VkStencilFaceFlags faceMask, uint32_t compareMask); | |
2298 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBu
ffer, VkStencilFaceFlags faceMask, uint32_t writeMask); | |
2299 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBu
ffer, VkStencilFaceFlags faceMask, uint32_t reference); | |
2300 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuf
fer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t fi
rstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uin
t32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); | |
2301 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer
, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); | |
2302 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuff
er, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, cons
t VkDeviceSize* pOffsets); | |
2303 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t
vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstanc
e); | |
2304 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, ui
nt32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOf
fset, uint32_t firstInstance); | |
2305 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, V
kBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); | |
2306 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBu
ffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
; | |
2307 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint3
2_t x, uint32_t y, uint32_t z); | |
2308 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffe
r, VkBuffer buffer, VkDeviceSize offset); | |
2309 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkB
uffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* p
Regions); | |
2310 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkIm
age srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstI
mageLayout, uint32_t regionCount, const VkImageCopy* pRegions); | |
2311 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkIm
age srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstI
mageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); | |
2312 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuff
er, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t
regionCount, const VkBufferImageCopy* pRegions); | |
2313 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuff
er, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t
regionCount, const VkBufferImageCopy* pRegions); | |
2314 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, V
kBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t
* pData); | |
2315 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkB
uffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); | |
2316 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer
, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uin
t32_t rangeCount, const VkImageSubresourceRange* pRanges); | |
2317 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer comman
dBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValu
e* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); | |
2318 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffe
r, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rec
tCount, const VkClearRect* pRects); | |
2319 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, V
kImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout d
stImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); | |
2320 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEve
nt event, VkPipelineStageFlags stageMask); | |
2321 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkE
vent event, VkPipelineStageFlags stageMask); | |
2322 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uin
t32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkP
ipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarri
er* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarr
ier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemor
yBarrier* pImageMemoryBarriers); | |
2323 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer
, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDepend
encyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* p
MemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier*
pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarr
ier* pImageMemoryBarriers); | |
2324 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQ
ueryPool queryPool, uint32_t query, VkQueryControlFlags flags); | |
2325 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQue
ryPool queryPool, uint32_t query); | |
2326 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer,
VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); | |
2327 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); | |
2328 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandB
uffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer
dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flag
s); | |
2329 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer,
VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_
t size, const void* pValues); | |
2330 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer
, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); | |
2331 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, Vk
SubpassContents contents); | |
2332 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); | |
2333 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer
, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); | |
2334 | |
2335 #ifndef VK_NO_PROTOTYPES | |
2336 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( | |
2337 const VkInstanceCreateInfo* pCreateInfo, | |
2338 const VkAllocationCallbacks* pAllocator, | |
2339 VkInstance* pInstance); | |
2340 | |
2341 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( | |
2342 VkInstance instance, | |
2343 const VkAllocationCallbacks* pAllocator); | |
2344 | |
2345 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( | |
2346 VkInstance instance, | |
2347 uint32_t* pPhysicalDeviceCount, | |
2348 VkPhysicalDevice* pPhysicalDevices); | |
2349 | |
2350 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( | |
2351 VkPhysicalDevice physicalDevice, | |
2352 VkPhysicalDeviceFeatures* pFeatures); | |
2353 | |
2354 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( | |
2355 VkPhysicalDevice physicalDevice, | |
2356 VkFormat format, | |
2357 VkFormatProperties* pFormatProperties); | |
2358 | |
2359 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( | |
2360 VkPhysicalDevice physicalDevice, | |
2361 VkFormat format, | |
2362 VkImageType type, | |
2363 VkImageTiling tiling, | |
2364 VkImageUsageFlags usage, | |
2365 VkImageCreateFlags flags, | |
2366 VkImageFormatProperties* pImageFormatProperties); | |
2367 | |
2368 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( | |
2369 VkPhysicalDevice physicalDevice, | |
2370 VkPhysicalDeviceProperties* pProperties); | |
2371 | |
2372 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( | |
2373 VkPhysicalDevice physicalDevice, | |
2374 uint32_t* pQueueFamilyPropertyCount, | |
2375 VkQueueFamilyProperties* pQueueFamilyProperties); | |
2376 | |
2377 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( | |
2378 VkPhysicalDevice physicalDevice, | |
2379 VkPhysicalDeviceMemoryProperties* pMemoryProperties); | |
2380 | |
2381 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( | |
2382 VkInstance instance, | |
2383 const char* pName); | |
2384 | |
2385 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( | |
2386 VkDevice device, | |
2387 const char* pName); | |
2388 | |
2389 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( | |
2390 VkPhysicalDevice physicalDevice, | |
2391 const VkDeviceCreateInfo* pCreateInfo, | |
2392 const VkAllocationCallbacks* pAllocator, | |
2393 VkDevice* pDevice); | |
2394 | |
2395 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( | |
2396 VkDevice device, | |
2397 const VkAllocationCallbacks* pAllocator); | |
2398 | |
2399 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( | |
2400 const char* pLayerName, | |
2401 uint32_t* pPropertyCount, | |
2402 VkExtensionProperties* pProperties); | |
2403 | |
2404 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( | |
2405 VkPhysicalDevice physicalDevice, | |
2406 const char* pLayerName, | |
2407 uint32_t* pPropertyCount, | |
2408 VkExtensionProperties* pProperties); | |
2409 | |
2410 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( | |
2411 uint32_t* pPropertyCount, | |
2412 VkLayerProperties* pProperties); | |
2413 | |
2414 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( | |
2415 VkPhysicalDevice physicalDevice, | |
2416 uint32_t* pPropertyCount, | |
2417 VkLayerProperties* pProperties); | |
2418 | |
2419 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( | |
2420 VkDevice device, | |
2421 uint32_t queueFamilyIndex, | |
2422 uint32_t queueIndex, | |
2423 VkQueue* pQueue); | |
2424 | |
2425 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( | |
2426 VkQueue queue, | |
2427 uint32_t submitCount, | |
2428 const VkSubmitInfo* pSubmits, | |
2429 VkFence fence); | |
2430 | |
2431 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( | |
2432 VkQueue queue); | |
2433 | |
2434 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( | |
2435 VkDevice device); | |
2436 | |
2437 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( | |
2438 VkDevice device, | |
2439 const VkMemoryAllocateInfo* pAllocateInfo, | |
2440 const VkAllocationCallbacks* pAllocator, | |
2441 VkDeviceMemory* pMemory); | |
2442 | |
2443 VKAPI_ATTR void VKAPI_CALL vkFreeMemory( | |
2444 VkDevice device, | |
2445 VkDeviceMemory memory, | |
2446 const VkAllocationCallbacks* pAllocator); | |
2447 | |
2448 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( | |
2449 VkDevice device, | |
2450 VkDeviceMemory memory, | |
2451 VkDeviceSize offset, | |
2452 VkDeviceSize size, | |
2453 VkMemoryMapFlags flags, | |
2454 void** ppData); | |
2455 | |
2456 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( | |
2457 VkDevice device, | |
2458 VkDeviceMemory memory); | |
2459 | |
2460 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( | |
2461 VkDevice device, | |
2462 uint32_t memoryRangeCount, | |
2463 const VkMappedMemoryRange* pMemoryRanges); | |
2464 | |
2465 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( | |
2466 VkDevice device, | |
2467 uint32_t memoryRangeCount, | |
2468 const VkMappedMemoryRange* pMemoryRanges); | |
2469 | |
2470 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( | |
2471 VkDevice device, | |
2472 VkDeviceMemory memory, | |
2473 VkDeviceSize* pCommittedMemoryInBytes); | |
2474 | |
2475 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( | |
2476 VkDevice device, | |
2477 VkBuffer buffer, | |
2478 VkDeviceMemory memory, | |
2479 VkDeviceSize memoryOffset); | |
2480 | |
2481 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( | |
2482 VkDevice device, | |
2483 VkImage image, | |
2484 VkDeviceMemory memory, | |
2485 VkDeviceSize memoryOffset); | |
2486 | |
2487 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( | |
2488 VkDevice device, | |
2489 VkBuffer buffer, | |
2490 VkMemoryRequirements* pMemoryRequirements); | |
2491 | |
2492 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( | |
2493 VkDevice device, | |
2494 VkImage image, | |
2495 VkMemoryRequirements* pMemoryRequirements); | |
2496 | |
2497 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( | |
2498 VkDevice device, | |
2499 VkImage image, | |
2500 uint32_t* pSparseMemoryRequirementCount, | |
2501 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); | |
2502 | |
2503 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( | |
2504 VkPhysicalDevice physicalDevice, | |
2505 VkFormat format, | |
2506 VkImageType type, | |
2507 VkSampleCountFlagBits samples, | |
2508 VkImageUsageFlags usage, | |
2509 VkImageTiling tiling, | |
2510 uint32_t* pPropertyCount, | |
2511 VkSparseImageFormatProperties* pProperties); | |
2512 | |
2513 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( | |
2514 VkQueue queue, | |
2515 uint32_t bindInfoCount, | |
2516 const VkBindSparseInfo* pBindInfo, | |
2517 VkFence fence); | |
2518 | |
2519 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( | |
2520 VkDevice device, | |
2521 const VkFenceCreateInfo* pCreateInfo, | |
2522 const VkAllocationCallbacks* pAllocator, | |
2523 VkFence* pFence); | |
2524 | |
2525 VKAPI_ATTR void VKAPI_CALL vkDestroyFence( | |
2526 VkDevice device, | |
2527 VkFence fence, | |
2528 const VkAllocationCallbacks* pAllocator); | |
2529 | |
2530 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( | |
2531 VkDevice device, | |
2532 uint32_t fenceCount, | |
2533 const VkFence* pFences); | |
2534 | |
2535 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( | |
2536 VkDevice device, | |
2537 VkFence fence); | |
2538 | |
2539 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( | |
2540 VkDevice device, | |
2541 uint32_t fenceCount, | |
2542 const VkFence* pFences, | |
2543 VkBool32 waitAll, | |
2544 uint64_t timeout); | |
2545 | |
2546 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( | |
2547 VkDevice device, | |
2548 const VkSemaphoreCreateInfo* pCreateInfo, | |
2549 const VkAllocationCallbacks* pAllocator, | |
2550 VkSemaphore* pSemaphore); | |
2551 | |
2552 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( | |
2553 VkDevice device, | |
2554 VkSemaphore semaphore, | |
2555 const VkAllocationCallbacks* pAllocator); | |
2556 | |
2557 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( | |
2558 VkDevice device, | |
2559 const VkEventCreateInfo* pCreateInfo, | |
2560 const VkAllocationCallbacks* pAllocator, | |
2561 VkEvent* pEvent); | |
2562 | |
2563 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( | |
2564 VkDevice device, | |
2565 VkEvent event, | |
2566 const VkAllocationCallbacks* pAllocator); | |
2567 | |
2568 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( | |
2569 VkDevice device, | |
2570 VkEvent event); | |
2571 | |
2572 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( | |
2573 VkDevice device, | |
2574 VkEvent event); | |
2575 | |
2576 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( | |
2577 VkDevice device, | |
2578 VkEvent event); | |
2579 | |
2580 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( | |
2581 VkDevice device, | |
2582 const VkQueryPoolCreateInfo* pCreateInfo, | |
2583 const VkAllocationCallbacks* pAllocator, | |
2584 VkQueryPool* pQueryPool); | |
2585 | |
2586 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( | |
2587 VkDevice device, | |
2588 VkQueryPool queryPool, | |
2589 const VkAllocationCallbacks* pAllocator); | |
2590 | |
2591 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( | |
2592 VkDevice device, | |
2593 VkQueryPool queryPool, | |
2594 uint32_t firstQuery, | |
2595 uint32_t queryCount, | |
2596 size_t dataSize, | |
2597 void* pData, | |
2598 VkDeviceSize stride, | |
2599 VkQueryResultFlags flags); | |
2600 | |
2601 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( | |
2602 VkDevice device, | |
2603 const VkBufferCreateInfo* pCreateInfo, | |
2604 const VkAllocationCallbacks* pAllocator, | |
2605 VkBuffer* pBuffer); | |
2606 | |
2607 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( | |
2608 VkDevice device, | |
2609 VkBuffer buffer, | |
2610 const VkAllocationCallbacks* pAllocator); | |
2611 | |
2612 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( | |
2613 VkDevice device, | |
2614 const VkBufferViewCreateInfo* pCreateInfo, | |
2615 const VkAllocationCallbacks* pAllocator, | |
2616 VkBufferView* pView); | |
2617 | |
2618 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( | |
2619 VkDevice device, | |
2620 VkBufferView bufferView, | |
2621 const VkAllocationCallbacks* pAllocator); | |
2622 | |
2623 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( | |
2624 VkDevice device, | |
2625 const VkImageCreateInfo* pCreateInfo, | |
2626 const VkAllocationCallbacks* pAllocator, | |
2627 VkImage* pImage); | |
2628 | |
2629 VKAPI_ATTR void VKAPI_CALL vkDestroyImage( | |
2630 VkDevice device, | |
2631 VkImage image, | |
2632 const VkAllocationCallbacks* pAllocator); | |
2633 | |
2634 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( | |
2635 VkDevice device, | |
2636 VkImage image, | |
2637 const VkImageSubresource* pSubresource, | |
2638 VkSubresourceLayout* pLayout); | |
2639 | |
2640 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( | |
2641 VkDevice device, | |
2642 const VkImageViewCreateInfo* pCreateInfo, | |
2643 const VkAllocationCallbacks* pAllocator, | |
2644 VkImageView* pView); | |
2645 | |
2646 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( | |
2647 VkDevice device, | |
2648 VkImageView imageView, | |
2649 const VkAllocationCallbacks* pAllocator); | |
2650 | |
2651 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( | |
2652 VkDevice device, | |
2653 const VkShaderModuleCreateInfo* pCreateInfo, | |
2654 const VkAllocationCallbacks* pAllocator, | |
2655 VkShaderModule* pShaderModule); | |
2656 | |
2657 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( | |
2658 VkDevice device, | |
2659 VkShaderModule shaderModule, | |
2660 const VkAllocationCallbacks* pAllocator); | |
2661 | |
2662 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( | |
2663 VkDevice device, | |
2664 const VkPipelineCacheCreateInfo* pCreateInfo, | |
2665 const VkAllocationCallbacks* pAllocator, | |
2666 VkPipelineCache* pPipelineCache); | |
2667 | |
2668 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( | |
2669 VkDevice device, | |
2670 VkPipelineCache pipelineCache, | |
2671 const VkAllocationCallbacks* pAllocator); | |
2672 | |
2673 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( | |
2674 VkDevice device, | |
2675 VkPipelineCache pipelineCache, | |
2676 size_t* pDataSize, | |
2677 void* pData); | |
2678 | |
2679 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( | |
2680 VkDevice device, | |
2681 VkPipelineCache dstCache, | |
2682 uint32_t srcCacheCount, | |
2683 const VkPipelineCache* pSrcCaches); | |
2684 | |
2685 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( | |
2686 VkDevice device, | |
2687 VkPipelineCache pipelineCache, | |
2688 uint32_t createInfoCount, | |
2689 const VkGraphicsPipelineCreateInfo* pCreateInfos, | |
2690 const VkAllocationCallbacks* pAllocator, | |
2691 VkPipeline* pPipelines); | |
2692 | |
2693 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( | |
2694 VkDevice device, | |
2695 VkPipelineCache pipelineCache, | |
2696 uint32_t createInfoCount, | |
2697 const VkComputePipelineCreateInfo* pCreateInfos, | |
2698 const VkAllocationCallbacks* pAllocator, | |
2699 VkPipeline* pPipelines); | |
2700 | |
2701 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( | |
2702 VkDevice device, | |
2703 VkPipeline pipeline, | |
2704 const VkAllocationCallbacks* pAllocator); | |
2705 | |
2706 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( | |
2707 VkDevice device, | |
2708 const VkPipelineLayoutCreateInfo* pCreateInfo, | |
2709 const VkAllocationCallbacks* pAllocator, | |
2710 VkPipelineLayout* pPipelineLayout); | |
2711 | |
2712 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( | |
2713 VkDevice device, | |
2714 VkPipelineLayout pipelineLayout, | |
2715 const VkAllocationCallbacks* pAllocator); | |
2716 | |
2717 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( | |
2718 VkDevice device, | |
2719 const VkSamplerCreateInfo* pCreateInfo, | |
2720 const VkAllocationCallbacks* pAllocator, | |
2721 VkSampler* pSampler); | |
2722 | |
2723 VKAPI_ATTR void VKAPI_CALL vkDestroySampler( | |
2724 VkDevice device, | |
2725 VkSampler sampler, | |
2726 const VkAllocationCallbacks* pAllocator); | |
2727 | |
2728 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( | |
2729 VkDevice device, | |
2730 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
2731 const VkAllocationCallbacks* pAllocator, | |
2732 VkDescriptorSetLayout* pSetLayout); | |
2733 | |
2734 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( | |
2735 VkDevice device, | |
2736 VkDescriptorSetLayout descriptorSetLayout, | |
2737 const VkAllocationCallbacks* pAllocator); | |
2738 | |
2739 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( | |
2740 VkDevice device, | |
2741 const VkDescriptorPoolCreateInfo* pCreateInfo, | |
2742 const VkAllocationCallbacks* pAllocator, | |
2743 VkDescriptorPool* pDescriptorPool); | |
2744 | |
2745 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( | |
2746 VkDevice device, | |
2747 VkDescriptorPool descriptorPool, | |
2748 const VkAllocationCallbacks* pAllocator); | |
2749 | |
2750 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( | |
2751 VkDevice device, | |
2752 VkDescriptorPool descriptorPool, | |
2753 VkDescriptorPoolResetFlags flags); | |
2754 | |
2755 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( | |
2756 VkDevice device, | |
2757 const VkDescriptorSetAllocateInfo* pAllocateInfo, | |
2758 VkDescriptorSet* pDescriptorSets); | |
2759 | |
2760 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( | |
2761 VkDevice device, | |
2762 VkDescriptorPool descriptorPool, | |
2763 uint32_t descriptorSetCount, | |
2764 const VkDescriptorSet* pDescriptorSets); | |
2765 | |
2766 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( | |
2767 VkDevice device, | |
2768 uint32_t descriptorWriteCount, | |
2769 const VkWriteDescriptorSet* pDescriptorWrites, | |
2770 uint32_t descriptorCopyCount, | |
2771 const VkCopyDescriptorSet* pDescriptorCopies); | |
2772 | |
2773 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( | |
2774 VkDevice device, | |
2775 const VkFramebufferCreateInfo* pCreateInfo, | |
2776 const VkAllocationCallbacks* pAllocator, | |
2777 VkFramebuffer* pFramebuffer); | |
2778 | |
2779 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( | |
2780 VkDevice device, | |
2781 VkFramebuffer framebuffer, | |
2782 const VkAllocationCallbacks* pAllocator); | |
2783 | |
2784 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( | |
2785 VkDevice device, | |
2786 const VkRenderPassCreateInfo* pCreateInfo, | |
2787 const VkAllocationCallbacks* pAllocator, | |
2788 VkRenderPass* pRenderPass); | |
2789 | |
2790 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( | |
2791 VkDevice device, | |
2792 VkRenderPass renderPass, | |
2793 const VkAllocationCallbacks* pAllocator); | |
2794 | |
2795 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( | |
2796 VkDevice device, | |
2797 VkRenderPass renderPass, | |
2798 VkExtent2D* pGranularity); | |
2799 | |
2800 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( | |
2801 VkDevice device, | |
2802 const VkCommandPoolCreateInfo* pCreateInfo, | |
2803 const VkAllocationCallbacks* pAllocator, | |
2804 VkCommandPool* pCommandPool); | |
2805 | |
2806 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( | |
2807 VkDevice device, | |
2808 VkCommandPool commandPool, | |
2809 const VkAllocationCallbacks* pAllocator); | |
2810 | |
2811 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( | |
2812 VkDevice device, | |
2813 VkCommandPool commandPool, | |
2814 VkCommandPoolResetFlags flags); | |
2815 | |
2816 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( | |
2817 VkDevice device, | |
2818 const VkCommandBufferAllocateInfo* pAllocateInfo, | |
2819 VkCommandBuffer* pCommandBuffers); | |
2820 | |
2821 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( | |
2822 VkDevice device, | |
2823 VkCommandPool commandPool, | |
2824 uint32_t commandBufferCount, | |
2825 const VkCommandBuffer* pCommandBuffers); | |
2826 | |
2827 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( | |
2828 VkCommandBuffer commandBuffer, | |
2829 const VkCommandBufferBeginInfo* pBeginInfo); | |
2830 | |
2831 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( | |
2832 VkCommandBuffer commandBuffer); | |
2833 | |
2834 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( | |
2835 VkCommandBuffer commandBuffer, | |
2836 VkCommandBufferResetFlags flags); | |
2837 | |
2838 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( | |
2839 VkCommandBuffer commandBuffer, | |
2840 VkPipelineBindPoint pipelineBindPoint, | |
2841 VkPipeline pipeline); | |
2842 | |
2843 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( | |
2844 VkCommandBuffer commandBuffer, | |
2845 uint32_t firstViewport, | |
2846 uint32_t viewportCount, | |
2847 const VkViewport* pViewports); | |
2848 | |
2849 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( | |
2850 VkCommandBuffer commandBuffer, | |
2851 uint32_t firstScissor, | |
2852 uint32_t scissorCount, | |
2853 const VkRect2D* pScissors); | |
2854 | |
2855 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( | |
2856 VkCommandBuffer commandBuffer, | |
2857 float lineWidth); | |
2858 | |
2859 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( | |
2860 VkCommandBuffer commandBuffer, | |
2861 float depthBiasConstantFactor, | |
2862 float depthBiasClamp, | |
2863 float depthBiasSlopeFactor); | |
2864 | |
2865 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( | |
2866 VkCommandBuffer commandBuffer, | |
2867 const float blendConstants[4]); | |
2868 | |
2869 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( | |
2870 VkCommandBuffer commandBuffer, | |
2871 float minDepthBounds, | |
2872 float maxDepthBounds); | |
2873 | |
2874 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( | |
2875 VkCommandBuffer commandBuffer, | |
2876 VkStencilFaceFlags faceMask, | |
2877 uint32_t compareMask); | |
2878 | |
2879 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( | |
2880 VkCommandBuffer commandBuffer, | |
2881 VkStencilFaceFlags faceMask, | |
2882 uint32_t writeMask); | |
2883 | |
2884 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( | |
2885 VkCommandBuffer commandBuffer, | |
2886 VkStencilFaceFlags faceMask, | |
2887 uint32_t reference); | |
2888 | |
2889 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( | |
2890 VkCommandBuffer commandBuffer, | |
2891 VkPipelineBindPoint pipelineBindPoint, | |
2892 VkPipelineLayout layout, | |
2893 uint32_t firstSet, | |
2894 uint32_t descriptorSetCount, | |
2895 const VkDescriptorSet* pDescriptorSets, | |
2896 uint32_t dynamicOffsetCount, | |
2897 const uint32_t* pDynamicOffsets); | |
2898 | |
2899 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( | |
2900 VkCommandBuffer commandBuffer, | |
2901 VkBuffer buffer, | |
2902 VkDeviceSize offset, | |
2903 VkIndexType indexType); | |
2904 | |
2905 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( | |
2906 VkCommandBuffer commandBuffer, | |
2907 uint32_t firstBinding, | |
2908 uint32_t bindingCount, | |
2909 const VkBuffer* pBuffers, | |
2910 const VkDeviceSize* pOffsets); | |
2911 | |
2912 VKAPI_ATTR void VKAPI_CALL vkCmdDraw( | |
2913 VkCommandBuffer commandBuffer, | |
2914 uint32_t vertexCount, | |
2915 uint32_t instanceCount, | |
2916 uint32_t firstVertex, | |
2917 uint32_t firstInstance); | |
2918 | |
2919 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( | |
2920 VkCommandBuffer commandBuffer, | |
2921 uint32_t indexCount, | |
2922 uint32_t instanceCount, | |
2923 uint32_t firstIndex, | |
2924 int32_t vertexOffset, | |
2925 uint32_t firstInstance); | |
2926 | |
2927 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( | |
2928 VkCommandBuffer commandBuffer, | |
2929 VkBuffer buffer, | |
2930 VkDeviceSize offset, | |
2931 uint32_t drawCount, | |
2932 uint32_t stride); | |
2933 | |
2934 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( | |
2935 VkCommandBuffer commandBuffer, | |
2936 VkBuffer buffer, | |
2937 VkDeviceSize offset, | |
2938 uint32_t drawCount, | |
2939 uint32_t stride); | |
2940 | |
2941 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( | |
2942 VkCommandBuffer commandBuffer, | |
2943 uint32_t x, | |
2944 uint32_t y, | |
2945 uint32_t z); | |
2946 | |
2947 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( | |
2948 VkCommandBuffer commandBuffer, | |
2949 VkBuffer buffer, | |
2950 VkDeviceSize offset); | |
2951 | |
2952 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( | |
2953 VkCommandBuffer commandBuffer, | |
2954 VkBuffer srcBuffer, | |
2955 VkBuffer dstBuffer, | |
2956 uint32_t regionCount, | |
2957 const VkBufferCopy* pRegions); | |
2958 | |
2959 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( | |
2960 VkCommandBuffer commandBuffer, | |
2961 VkImage srcImage, | |
2962 VkImageLayout srcImageLayout, | |
2963 VkImage dstImage, | |
2964 VkImageLayout dstImageLayout, | |
2965 uint32_t regionCount, | |
2966 const VkImageCopy* pRegions); | |
2967 | |
2968 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( | |
2969 VkCommandBuffer commandBuffer, | |
2970 VkImage srcImage, | |
2971 VkImageLayout srcImageLayout, | |
2972 VkImage dstImage, | |
2973 VkImageLayout dstImageLayout, | |
2974 uint32_t regionCount, | |
2975 const VkImageBlit* pRegions, | |
2976 VkFilter filter); | |
2977 | |
2978 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( | |
2979 VkCommandBuffer commandBuffer, | |
2980 VkBuffer srcBuffer, | |
2981 VkImage dstImage, | |
2982 VkImageLayout dstImageLayout, | |
2983 uint32_t regionCount, | |
2984 const VkBufferImageCopy* pRegions); | |
2985 | |
2986 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( | |
2987 VkCommandBuffer commandBuffer, | |
2988 VkImage srcImage, | |
2989 VkImageLayout srcImageLayout, | |
2990 VkBuffer dstBuffer, | |
2991 uint32_t regionCount, | |
2992 const VkBufferImageCopy* pRegions); | |
2993 | |
2994 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( | |
2995 VkCommandBuffer commandBuffer, | |
2996 VkBuffer dstBuffer, | |
2997 VkDeviceSize dstOffset, | |
2998 VkDeviceSize dataSize, | |
2999 const uint32_t* pData); | |
3000 | |
3001 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( | |
3002 VkCommandBuffer commandBuffer, | |
3003 VkBuffer dstBuffer, | |
3004 VkDeviceSize dstOffset, | |
3005 VkDeviceSize size, | |
3006 uint32_t data); | |
3007 | |
3008 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( | |
3009 VkCommandBuffer commandBuffer, | |
3010 VkImage image, | |
3011 VkImageLayout imageLayout, | |
3012 const VkClearColorValue* pColor, | |
3013 uint32_t rangeCount, | |
3014 const VkImageSubresourceRange* pRanges); | |
3015 | |
3016 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( | |
3017 VkCommandBuffer commandBuffer, | |
3018 VkImage image, | |
3019 VkImageLayout imageLayout, | |
3020 const VkClearDepthStencilValue* pDepthStencil, | |
3021 uint32_t rangeCount, | |
3022 const VkImageSubresourceRange* pRanges); | |
3023 | |
3024 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( | |
3025 VkCommandBuffer commandBuffer, | |
3026 uint32_t attachmentCount, | |
3027 const VkClearAttachment* pAttachments, | |
3028 uint32_t rectCount, | |
3029 const VkClearRect* pRects); | |
3030 | |
3031 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( | |
3032 VkCommandBuffer commandBuffer, | |
3033 VkImage srcImage, | |
3034 VkImageLayout srcImageLayout, | |
3035 VkImage dstImage, | |
3036 VkImageLayout dstImageLayout, | |
3037 uint32_t regionCount, | |
3038 const VkImageResolve* pRegions); | |
3039 | |
3040 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( | |
3041 VkCommandBuffer commandBuffer, | |
3042 VkEvent event, | |
3043 VkPipelineStageFlags stageMask); | |
3044 | |
3045 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( | |
3046 VkCommandBuffer commandBuffer, | |
3047 VkEvent event, | |
3048 VkPipelineStageFlags stageMask); | |
3049 | |
3050 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( | |
3051 VkCommandBuffer commandBuffer, | |
3052 uint32_t eventCount, | |
3053 const VkEvent* pEvents, | |
3054 VkPipelineStageFlags srcStageMask, | |
3055 VkPipelineStageFlags dstStageMask, | |
3056 uint32_t memoryBarrierCount, | |
3057 const VkMemoryBarrier* pMemoryBarriers, | |
3058 uint32_t bufferMemoryBarrierCount, | |
3059 const VkBufferMemoryBarrier* pBufferMemoryBarriers, | |
3060 uint32_t imageMemoryBarrierCount, | |
3061 const VkImageMemoryBarrier* pImageMemoryBarriers); | |
3062 | |
3063 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( | |
3064 VkCommandBuffer commandBuffer, | |
3065 VkPipelineStageFlags srcStageMask, | |
3066 VkPipelineStageFlags dstStageMask, | |
3067 VkDependencyFlags dependencyFlags, | |
3068 uint32_t memoryBarrierCount, | |
3069 const VkMemoryBarrier* pMemoryBarriers, | |
3070 uint32_t bufferMemoryBarrierCount, | |
3071 const VkBufferMemoryBarrier* pBufferMemoryBarriers, | |
3072 uint32_t imageMemoryBarrierCount, | |
3073 const VkImageMemoryBarrier* pImageMemoryBarriers); | |
3074 | |
3075 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( | |
3076 VkCommandBuffer commandBuffer, | |
3077 VkQueryPool queryPool, | |
3078 uint32_t query, | |
3079 VkQueryControlFlags flags); | |
3080 | |
3081 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( | |
3082 VkCommandBuffer commandBuffer, | |
3083 VkQueryPool queryPool, | |
3084 uint32_t query); | |
3085 | |
3086 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( | |
3087 VkCommandBuffer commandBuffer, | |
3088 VkQueryPool queryPool, | |
3089 uint32_t firstQuery, | |
3090 uint32_t queryCount); | |
3091 | |
3092 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( | |
3093 VkCommandBuffer commandBuffer, | |
3094 VkPipelineStageFlagBits pipelineStage, | |
3095 VkQueryPool queryPool, | |
3096 uint32_t query); | |
3097 | |
3098 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( | |
3099 VkCommandBuffer commandBuffer, | |
3100 VkQueryPool queryPool, | |
3101 uint32_t firstQuery, | |
3102 uint32_t queryCount, | |
3103 VkBuffer dstBuffer, | |
3104 VkDeviceSize dstOffset, | |
3105 VkDeviceSize stride, | |
3106 VkQueryResultFlags flags); | |
3107 | |
3108 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( | |
3109 VkCommandBuffer commandBuffer, | |
3110 VkPipelineLayout layout, | |
3111 VkShaderStageFlags stageFlags, | |
3112 uint32_t offset, | |
3113 uint32_t size, | |
3114 const void* pValues); | |
3115 | |
3116 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( | |
3117 VkCommandBuffer commandBuffer, | |
3118 const VkRenderPassBeginInfo* pRenderPassBegin, | |
3119 VkSubpassContents contents); | |
3120 | |
3121 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( | |
3122 VkCommandBuffer commandBuffer, | |
3123 VkSubpassContents contents); | |
3124 | |
3125 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( | |
3126 VkCommandBuffer commandBuffer); | |
3127 | |
3128 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( | |
3129 VkCommandBuffer commandBuffer, | |
3130 uint32_t commandBufferCount, | |
3131 const VkCommandBuffer* pCommandBuffers); | |
3132 #endif | |
3133 | |
3134 #define VK_KHR_surface 1 | |
3135 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) | |
3136 | |
3137 #define VK_KHR_SURFACE_SPEC_VERSION 25 | |
3138 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" | |
3139 | |
3140 | |
3141 typedef enum VkColorSpaceKHR { | |
3142 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, | |
3143 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, | |
3144 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, | |
3145 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE
_SRGB_NONLINEAR_KHR + 1), | |
3146 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF | |
3147 } VkColorSpaceKHR; | |
3148 | |
3149 typedef enum VkPresentModeKHR { | |
3150 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, | |
3151 VK_PRESENT_MODE_MAILBOX_KHR = 1, | |
3152 VK_PRESENT_MODE_FIFO_KHR = 2, | |
3153 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, | |
3154 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, | |
3155 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, | |
3156 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_
MODE_IMMEDIATE_KHR + 1), | |
3157 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF | |
3158 } VkPresentModeKHR; | |
3159 | |
3160 | |
3161 typedef enum VkSurfaceTransformFlagBitsKHR { | |
3162 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, | |
3163 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, | |
3164 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, | |
3165 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, | |
3166 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, | |
3167 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, | |
3168 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, | |
3169 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, | |
3170 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, | |
3171 } VkSurfaceTransformFlagBitsKHR; | |
3172 typedef VkFlags VkSurfaceTransformFlagsKHR; | |
3173 | |
3174 typedef enum VkCompositeAlphaFlagBitsKHR { | |
3175 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, | |
3176 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, | |
3177 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, | |
3178 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, | |
3179 } VkCompositeAlphaFlagBitsKHR; | |
3180 typedef VkFlags VkCompositeAlphaFlagsKHR; | |
3181 | |
3182 typedef struct VkSurfaceCapabilitiesKHR { | |
3183 uint32_t minImageCount; | |
3184 uint32_t maxImageCount; | |
3185 VkExtent2D currentExtent; | |
3186 VkExtent2D minImageExtent; | |
3187 VkExtent2D maxImageExtent; | |
3188 uint32_t maxImageArrayLayers; | |
3189 VkSurfaceTransformFlagsKHR supportedTransforms; | |
3190 VkSurfaceTransformFlagBitsKHR currentTransform; | |
3191 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; | |
3192 VkImageUsageFlags supportedUsageFlags; | |
3193 } VkSurfaceCapabilitiesKHR; | |
3194 | |
3195 typedef struct VkSurfaceFormatKHR { | |
3196 VkFormat format; | |
3197 VkColorSpaceKHR colorSpace; | |
3198 } VkSurfaceFormatKHR; | |
3199 | |
3200 | |
3201 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurface
KHR surface, const VkAllocationCallbacks* pAllocator); | |
3202 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysica
lDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool3
2* pSupported); | |
3203 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPh
ysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSu
rfaceCapabilities); | |
3204 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysica
lDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkS
urfaceFormatKHR* pSurfaceFormats); | |
3205 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPh
ysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes); | |
3206 | |
3207 #ifndef VK_NO_PROTOTYPES | |
3208 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( | |
3209 VkInstance instance, | |
3210 VkSurfaceKHR surface, | |
3211 const VkAllocationCallbacks* pAllocator); | |
3212 | |
3213 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( | |
3214 VkPhysicalDevice physicalDevice, | |
3215 uint32_t queueFamilyIndex, | |
3216 VkSurfaceKHR surface, | |
3217 VkBool32* pSupported); | |
3218 | |
3219 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
3220 VkPhysicalDevice physicalDevice, | |
3221 VkSurfaceKHR surface, | |
3222 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); | |
3223 | |
3224 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( | |
3225 VkPhysicalDevice physicalDevice, | |
3226 VkSurfaceKHR surface, | |
3227 uint32_t* pSurfaceFormatCount, | |
3228 VkSurfaceFormatKHR* pSurfaceFormats); | |
3229 | |
3230 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( | |
3231 VkPhysicalDevice physicalDevice, | |
3232 VkSurfaceKHR surface, | |
3233 uint32_t* pPresentModeCount, | |
3234 VkPresentModeKHR* pPresentModes); | |
3235 #endif | |
3236 | |
3237 #define VK_KHR_swapchain 1 | |
3238 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) | |
3239 | |
3240 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 | |
3241 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" | |
3242 | |
3243 typedef VkFlags VkSwapchainCreateFlagsKHR; | |
3244 | |
3245 typedef struct VkSwapchainCreateInfoKHR { | |
3246 VkStructureType sType; | |
3247 const void* pNext; | |
3248 VkSwapchainCreateFlagsKHR flags; | |
3249 VkSurfaceKHR surface; | |
3250 uint32_t minImageCount; | |
3251 VkFormat imageFormat; | |
3252 VkColorSpaceKHR imageColorSpace; | |
3253 VkExtent2D imageExtent; | |
3254 uint32_t imageArrayLayers; | |
3255 VkImageUsageFlags imageUsage; | |
3256 VkSharingMode imageSharingMode; | |
3257 uint32_t queueFamilyIndexCount; | |
3258 const uint32_t* pQueueFamilyIndices; | |
3259 VkSurfaceTransformFlagBitsKHR preTransform; | |
3260 VkCompositeAlphaFlagBitsKHR compositeAlpha; | |
3261 VkPresentModeKHR presentMode; | |
3262 VkBool32 clipped; | |
3263 VkSwapchainKHR oldSwapchain; | |
3264 } VkSwapchainCreateInfoKHR; | |
3265 | |
3266 typedef struct VkPresentInfoKHR { | |
3267 VkStructureType sType; | |
3268 const void* pNext; | |
3269 uint32_t waitSemaphoreCount; | |
3270 const VkSemaphore* pWaitSemaphores; | |
3271 uint32_t swapchainCount; | |
3272 const VkSwapchainKHR* pSwapchains; | |
3273 const uint32_t* pImageIndices; | |
3274 VkResult* pResults; | |
3275 } VkPresentInfoKHR; | |
3276 | |
3277 | |
3278 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const Vk
SwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, Vk
SwapchainKHR* pSwapchain); | |
3279 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchain
KHR swapchain, const VkAllocationCallbacks* pAllocator); | |
3280 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwa
pchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); | |
3281 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapc
hainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint3
2_t* pImageIndex); | |
3282 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPrese
ntInfoKHR* pPresentInfo); | |
3283 | |
3284 #ifndef VK_NO_PROTOTYPES | |
3285 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( | |
3286 VkDevice device, | |
3287 const VkSwapchainCreateInfoKHR* pCreateInfo, | |
3288 const VkAllocationCallbacks* pAllocator, | |
3289 VkSwapchainKHR* pSwapchain); | |
3290 | |
3291 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( | |
3292 VkDevice device, | |
3293 VkSwapchainKHR swapchain, | |
3294 const VkAllocationCallbacks* pAllocator); | |
3295 | |
3296 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( | |
3297 VkDevice device, | |
3298 VkSwapchainKHR swapchain, | |
3299 uint32_t* pSwapchainImageCount, | |
3300 VkImage* pSwapchainImages); | |
3301 | |
3302 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( | |
3303 VkDevice device, | |
3304 VkSwapchainKHR swapchain, | |
3305 uint64_t timeout, | |
3306 VkSemaphore semaphore, | |
3307 VkFence fence, | |
3308 uint32_t* pImageIndex); | |
3309 | |
3310 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( | |
3311 VkQueue queue, | |
3312 const VkPresentInfoKHR* pPresentInfo); | |
3313 #endif | |
3314 | |
3315 #define VK_KHR_display 1 | |
3316 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) | |
3317 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) | |
3318 | |
3319 #define VK_KHR_DISPLAY_SPEC_VERSION 21 | |
3320 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" | |
3321 | |
3322 | |
3323 typedef enum VkDisplayPlaneAlphaFlagBitsKHR { | |
3324 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, | |
3325 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, | |
3326 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, | |
3327 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, | |
3328 } VkDisplayPlaneAlphaFlagBitsKHR; | |
3329 typedef VkFlags VkDisplayModeCreateFlagsKHR; | |
3330 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; | |
3331 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; | |
3332 | |
3333 typedef struct VkDisplayPropertiesKHR { | |
3334 VkDisplayKHR display; | |
3335 const char* displayName; | |
3336 VkExtent2D physicalDimensions; | |
3337 VkExtent2D physicalResolution; | |
3338 VkSurfaceTransformFlagsKHR supportedTransforms; | |
3339 VkBool32 planeReorderPossible; | |
3340 VkBool32 persistentContent; | |
3341 } VkDisplayPropertiesKHR; | |
3342 | |
3343 typedef struct VkDisplayModeParametersKHR { | |
3344 VkExtent2D visibleRegion; | |
3345 uint32_t refreshRate; | |
3346 } VkDisplayModeParametersKHR; | |
3347 | |
3348 typedef struct VkDisplayModePropertiesKHR { | |
3349 VkDisplayModeKHR displayMode; | |
3350 VkDisplayModeParametersKHR parameters; | |
3351 } VkDisplayModePropertiesKHR; | |
3352 | |
3353 typedef struct VkDisplayModeCreateInfoKHR { | |
3354 VkStructureType sType; | |
3355 const void* pNext; | |
3356 VkDisplayModeCreateFlagsKHR flags; | |
3357 VkDisplayModeParametersKHR parameters; | |
3358 } VkDisplayModeCreateInfoKHR; | |
3359 | |
3360 typedef struct VkDisplayPlaneCapabilitiesKHR { | |
3361 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; | |
3362 VkOffset2D minSrcPosition; | |
3363 VkOffset2D maxSrcPosition; | |
3364 VkExtent2D minSrcExtent; | |
3365 VkExtent2D maxSrcExtent; | |
3366 VkOffset2D minDstPosition; | |
3367 VkOffset2D maxDstPosition; | |
3368 VkExtent2D minDstExtent; | |
3369 VkExtent2D maxDstExtent; | |
3370 } VkDisplayPlaneCapabilitiesKHR; | |
3371 | |
3372 typedef struct VkDisplayPlanePropertiesKHR { | |
3373 VkDisplayKHR currentDisplay; | |
3374 uint32_t currentStackIndex; | |
3375 } VkDisplayPlanePropertiesKHR; | |
3376 | |
3377 typedef struct VkDisplaySurfaceCreateInfoKHR { | |
3378 VkStructureType sType; | |
3379 const void* pNext; | |
3380 VkDisplaySurfaceCreateFlagsKHR flags; | |
3381 VkDisplayModeKHR displayMode; | |
3382 uint32_t planeIndex; | |
3383 uint32_t planeStackIndex; | |
3384 VkSurfaceTransformFlagBitsKHR transform; | |
3385 float globalAlpha; | |
3386 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; | |
3387 VkExtent2D imageExtent; | |
3388 } VkDisplaySurfaceCreateInfoKHR; | |
3389 | |
3390 | |
3391 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhys
icalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pPr
operties); | |
3392 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(V
kPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperti
esKHR* pProperties); | |
3393 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysic
alDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplay
KHR* pDisplays); | |
3394 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice
physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePr
opertiesKHR* pProperties); | |
3395 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physic
alDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, co
nst VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); | |
3396 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDev
ice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCa
pabilitiesKHR* pCapabilities); | |
3397 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance inst
ance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallba
cks* pAllocator, VkSurfaceKHR* pSurface); | |
3398 | |
3399 #ifndef VK_NO_PROTOTYPES | |
3400 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( | |
3401 VkPhysicalDevice physicalDevice, | |
3402 uint32_t* pPropertyCount, | |
3403 VkDisplayPropertiesKHR* pProperties); | |
3404 | |
3405 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
3406 VkPhysicalDevice physicalDevice, | |
3407 uint32_t* pPropertyCount, | |
3408 VkDisplayPlanePropertiesKHR* pProperties); | |
3409 | |
3410 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( | |
3411 VkPhysicalDevice physicalDevice, | |
3412 uint32_t planeIndex, | |
3413 uint32_t* pDisplayCount, | |
3414 VkDisplayKHR* pDisplays); | |
3415 | |
3416 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( | |
3417 VkPhysicalDevice physicalDevice, | |
3418 VkDisplayKHR display, | |
3419 uint32_t* pPropertyCount, | |
3420 VkDisplayModePropertiesKHR* pProperties); | |
3421 | |
3422 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( | |
3423 VkPhysicalDevice physicalDevice, | |
3424 VkDisplayKHR display, | |
3425 const VkDisplayModeCreateInfoKHR* pCreateInfo, | |
3426 const VkAllocationCallbacks* pAllocator, | |
3427 VkDisplayModeKHR* pMode); | |
3428 | |
3429 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( | |
3430 VkPhysicalDevice physicalDevice, | |
3431 VkDisplayModeKHR mode, | |
3432 uint32_t planeIndex, | |
3433 VkDisplayPlaneCapabilitiesKHR* pCapabilities); | |
3434 | |
3435 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( | |
3436 VkInstance instance, | |
3437 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, | |
3438 const VkAllocationCallbacks* pAllocator, | |
3439 VkSurfaceKHR* pSurface); | |
3440 #endif | |
3441 | |
3442 #define VK_KHR_display_swapchain 1 | |
3443 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 | |
3444 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" | |
3445 | |
3446 typedef struct VkDisplayPresentInfoKHR { | |
3447 VkStructureType sType; | |
3448 const void* pNext; | |
3449 VkRect2D srcRect; | |
3450 VkRect2D dstRect; | |
3451 VkBool32 persistent; | |
3452 } VkDisplayPresentInfoKHR; | |
3453 | |
3454 | |
3455 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, u
int32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAl
locationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); | |
3456 | |
3457 #ifndef VK_NO_PROTOTYPES | |
3458 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( | |
3459 VkDevice device, | |
3460 uint32_t swapchainCount, | |
3461 const VkSwapchainCreateInfoKHR* pCreateInfos, | |
3462 const VkAllocationCallbacks* pAllocator, | |
3463 VkSwapchainKHR* pSwapchains); | |
3464 #endif | |
3465 | |
3466 #ifdef VK_USE_PLATFORM_XLIB_KHR | |
3467 #define VK_KHR_xlib_surface 1 | |
3468 #include <X11/Xlib.h> | |
3469 | |
3470 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 | |
3471 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" | |
3472 | |
3473 typedef VkFlags VkXlibSurfaceCreateFlagsKHR; | |
3474 | |
3475 typedef struct VkXlibSurfaceCreateInfoKHR { | |
3476 VkStructureType sType; | |
3477 const void* pNext; | |
3478 VkXlibSurfaceCreateFlagsKHR flags; | |
3479 Display* dpy; | |
3480 Window window; | |
3481 } VkXlibSurfaceCreateInfoKHR; | |
3482 | |
3483 | |
3484 typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, co
nst VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAlloc
ator, VkSurfaceKHR* pSurface); | |
3485 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, Visual
ID visualID); | |
3486 | |
3487 #ifndef VK_NO_PROTOTYPES | |
3488 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( | |
3489 VkInstance instance, | |
3490 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, | |
3491 const VkAllocationCallbacks* pAllocator, | |
3492 VkSurfaceKHR* pSurface); | |
3493 | |
3494 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( | |
3495 VkPhysicalDevice physicalDevice, | |
3496 uint32_t queueFamilyIndex, | |
3497 Display* dpy, | |
3498 VisualID visualID); | |
3499 #endif | |
3500 #endif /* VK_USE_PLATFORM_XLIB_KHR */ | |
3501 | |
3502 #ifdef VK_USE_PLATFORM_XCB_KHR | |
3503 #define VK_KHR_xcb_surface 1 | |
3504 #include <xcb/xcb.h> | |
3505 | |
3506 #define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 | |
3507 #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" | |
3508 | |
3509 typedef VkFlags VkXcbSurfaceCreateFlagsKHR; | |
3510 | |
3511 typedef struct VkXcbSurfaceCreateInfoKHR { | |
3512 VkStructureType sType; | |
3513 const void* pNext; | |
3514 VkXcbSurfaceCreateFlagsKHR flags; | |
3515 xcb_connection_t* connection; | |
3516 xcb_window_t window; | |
3517 } VkXcbSurfaceCreateInfoKHR; | |
3518 | |
3519 | |
3520 typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, con
st VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocat
or, VkSurfaceKHR* pSurface); | |
3521 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(V
kPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* con
nection, xcb_visualid_t visual_id); | |
3522 | |
3523 #ifndef VK_NO_PROTOTYPES | |
3524 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( | |
3525 VkInstance instance, | |
3526 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, | |
3527 const VkAllocationCallbacks* pAllocator, | |
3528 VkSurfaceKHR* pSurface); | |
3529 | |
3530 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( | |
3531 VkPhysicalDevice physicalDevice, | |
3532 uint32_t queueFamilyIndex, | |
3533 xcb_connection_t* connection, | |
3534 xcb_visualid_t visual_id); | |
3535 #endif | |
3536 #endif /* VK_USE_PLATFORM_XCB_KHR */ | |
3537 | |
3538 #ifdef VK_USE_PLATFORM_WAYLAND_KHR | |
3539 #define VK_KHR_wayland_surface 1 | |
3540 #include <wayland-client.h> | |
3541 | |
3542 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5 | |
3543 #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" | |
3544 | |
3545 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; | |
3546 | |
3547 typedef struct VkWaylandSurfaceCreateInfoKHR { | |
3548 VkStructureType sType; | |
3549 const void* pNext; | |
3550 VkWaylandSurfaceCreateFlagsKHR flags; | |
3551 struct wl_display* display; | |
3552 struct wl_surface* surface; | |
3553 } VkWaylandSurfaceCreateInfoKHR; | |
3554 | |
3555 | |
3556 typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkSurfaceKHR* pSurface); | |
3557 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKH
R)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display
* display); | |
3558 | |
3559 #ifndef VK_NO_PROTOTYPES | |
3560 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( | |
3561 VkInstance instance, | |
3562 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, | |
3563 const VkAllocationCallbacks* pAllocator, | |
3564 VkSurfaceKHR* pSurface); | |
3565 | |
3566 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( | |
3567 VkPhysicalDevice physicalDevice, | |
3568 uint32_t queueFamilyIndex, | |
3569 struct wl_display* display); | |
3570 #endif | |
3571 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ | |
3572 | |
3573 #ifdef VK_USE_PLATFORM_MIR_KHR | |
3574 #define VK_KHR_mir_surface 1 | |
3575 #include <mir_toolkit/client_types.h> | |
3576 | |
3577 #define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 | |
3578 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" | |
3579 | |
3580 typedef VkFlags VkMirSurfaceCreateFlagsKHR; | |
3581 | |
3582 typedef struct VkMirSurfaceCreateInfoKHR { | |
3583 VkStructureType sType; | |
3584 const void* pNext; | |
3585 VkMirSurfaceCreateFlagsKHR flags; | |
3586 MirConnection* connection; | |
3587 MirSurface* mirSurface; | |
3588 } VkMirSurfaceCreateInfoKHR; | |
3589 | |
3590 | |
3591 typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, con
st VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocat
or, VkSurfaceKHR* pSurface); | |
3592 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(V
kPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connec
tion); | |
3593 | |
3594 #ifndef VK_NO_PROTOTYPES | |
3595 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( | |
3596 VkInstance instance, | |
3597 const VkMirSurfaceCreateInfoKHR* pCreateInfo, | |
3598 const VkAllocationCallbacks* pAllocator, | |
3599 VkSurfaceKHR* pSurface); | |
3600 | |
3601 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( | |
3602 VkPhysicalDevice physicalDevice, | |
3603 uint32_t queueFamilyIndex, | |
3604 MirConnection* connection); | |
3605 #endif | |
3606 #endif /* VK_USE_PLATFORM_MIR_KHR */ | |
3607 | |
3608 #ifdef VK_USE_PLATFORM_ANDROID_KHR | |
3609 #define VK_KHR_android_surface 1 | |
3610 #include <android/native_window.h> | |
3611 | |
3612 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 | |
3613 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" | |
3614 | |
3615 typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; | |
3616 | |
3617 typedef struct VkAndroidSurfaceCreateInfoKHR { | |
3618 VkStructureType sType; | |
3619 const void* pNext; | |
3620 VkAndroidSurfaceCreateFlagsKHR flags; | |
3621 ANativeWindow* window; | |
3622 } VkAndroidSurfaceCreateInfoKHR; | |
3623 | |
3624 | |
3625 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks*
pAllocator, VkSurfaceKHR* pSurface); | |
3626 | |
3627 #ifndef VK_NO_PROTOTYPES | |
3628 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( | |
3629 VkInstance instance, | |
3630 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, | |
3631 const VkAllocationCallbacks* pAllocator, | |
3632 VkSurfaceKHR* pSurface); | |
3633 #endif | |
3634 #endif /* VK_USE_PLATFORM_ANDROID_KHR */ | |
3635 | |
3636 #ifdef VK_USE_PLATFORM_WIN32_KHR | |
3637 #define VK_KHR_win32_surface 1 | |
3638 #include <windows.h> | |
3639 | |
3640 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 | |
3641 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" | |
3642 | |
3643 typedef VkFlags VkWin32SurfaceCreateFlagsKHR; | |
3644 | |
3645 typedef struct VkWin32SurfaceCreateInfoKHR { | |
3646 VkStructureType sType; | |
3647 const void* pNext; | |
3648 VkWin32SurfaceCreateFlagsKHR flags; | |
3649 HINSTANCE hinstance; | |
3650 HWND hwnd; | |
3651 } VkWin32SurfaceCreateInfoKHR; | |
3652 | |
3653 | |
3654 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, c
onst VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAll
ocator, VkSurfaceKHR* pSurface); | |
3655 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)
(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); | |
3656 | |
3657 #ifndef VK_NO_PROTOTYPES | |
3658 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( | |
3659 VkInstance instance, | |
3660 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, | |
3661 const VkAllocationCallbacks* pAllocator, | |
3662 VkSurfaceKHR* pSurface); | |
3663 | |
3664 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( | |
3665 VkPhysicalDevice physicalDevice, | |
3666 uint32_t queueFamilyIndex); | |
3667 #endif | |
3668 #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
3669 | |
3670 #define VK_EXT_debug_report 1 | |
3671 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) | |
3672 | |
3673 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 1 | |
3674 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" | |
3675 | |
3676 | |
3677 typedef enum VkDebugReportObjectTypeEXT { | |
3678 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, | |
3679 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, | |
3680 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, | |
3681 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, | |
3682 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, | |
3683 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, | |
3684 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, | |
3685 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, | |
3686 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, | |
3687 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, | |
3688 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, | |
3689 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, | |
3690 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, | |
3691 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, | |
3692 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, | |
3693 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, | |
3694 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, | |
3695 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, | |
3696 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, | |
3697 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, | |
3698 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, | |
3699 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, | |
3700 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, | |
3701 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, | |
3702 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, | |
3703 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, | |
3704 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, | |
3705 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, | |
3706 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, | |
3707 } VkDebugReportObjectTypeEXT; | |
3708 | |
3709 typedef enum VkDebugReportErrorEXT { | |
3710 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, | |
3711 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, | |
3712 } VkDebugReportErrorEXT; | |
3713 | |
3714 | |
3715 typedef enum VkDebugReportFlagBitsEXT { | |
3716 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, | |
3717 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, | |
3718 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, | |
3719 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, | |
3720 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, | |
3721 } VkDebugReportFlagBitsEXT; | |
3722 typedef VkFlags VkDebugReportFlagsEXT; | |
3723 | |
3724 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( | |
3725 VkDebugReportFlagsEXT flags, | |
3726 VkDebugReportObjectTypeEXT objectType, | |
3727 uint64_t object, | |
3728 size_t location, | |
3729 int32_t messageCode, | |
3730 const char* pLayerPrefix, | |
3731 const char* pMessage, | |
3732 void* pUserData); | |
3733 | |
3734 | |
3735 typedef struct VkDebugReportCallbackCreateInfoEXT { | |
3736 VkStructureType sType; | |
3737 const void* pNext; | |
3738 VkDebugReportFlagsEXT flags; | |
3739 PFN_vkDebugReportCallbackEXT pfnCallback; | |
3740 void* pUserData; | |
3741 } VkDebugReportCallbackCreateInfoEXT; | |
3742 | |
3743 | |
3744 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance inst
ance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationC
allbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); | |
3745 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instanc
e, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); | |
3746 typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDeb
ugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object,
size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMes
sage); | |
3747 | |
3748 #ifndef VK_NO_PROTOTYPES | |
3749 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( | |
3750 VkInstance instance, | |
3751 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, | |
3752 const VkAllocationCallbacks* pAllocator, | |
3753 VkDebugReportCallbackEXT* pCallback); | |
3754 | |
3755 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( | |
3756 VkInstance instance, | |
3757 VkDebugReportCallbackEXT callback, | |
3758 const VkAllocationCallbacks* pAllocator); | |
3759 | |
3760 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( | |
3761 VkInstance instance, | |
3762 VkDebugReportFlagsEXT flags, | |
3763 VkDebugReportObjectTypeEXT objectType, | |
3764 uint64_t object, | |
3765 size_t location, | |
3766 int32_t messageCode, | |
3767 const char* pLayerPrefix, | |
3768 const char* pMessage); | |
3769 #endif | |
3770 | |
3771 #ifdef __cplusplus | |
3772 } | |
3773 #endif | |
3774 | |
3775 #endif | |
OLD | NEW |