1 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
2 // See helper_file_generator.py for modifications
3
4
5 /***************************************************************************
6 *
7 * Copyright (c) 2015-2019 The Khronos Group Inc.
8 * Copyright (c) 2015-2019 Valve Corporation
9 * Copyright (c) 2015-2019 LunarG, Inc.
10 * Copyright (c) 2015-2019 Google Inc.
11 *
12 * Licensed under the Apache License, Version 2.0 (the "License");
13 * you may not use this file except in compliance with the License.
14 * You may obtain a copy of the License at
15 *
16 * http://www.apache.org/licenses/LICENSE-2.0
17 *
18 * Unless required by applicable law or agreed to in writing, software
19 * distributed under the License is distributed on an "AS IS" BASIS,
20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 * See the License for the specific language governing permissions and
22 * limitations under the License.
23 *
24 * Author: Mark Lobodzinski <mark@lunarg.com>
25 * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
26 * Author: Tobin Ehlis <tobine@google.com>
27 * Author: Chris Forbes <chrisforbes@google.com>
28 * Author: John Zulauf<jzulauf@lunarg.com>
29 *
30 ****************************************************************************/
31
32
33 #pragma once
34 #ifdef _WIN32
35 #pragma warning( disable : 4065 )
36 #endif
37
38 #include <string>
39 #include <vulkan/vulkan.h>
40
41
string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)42 static inline const char* string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)
43 {
44 switch ((VkPipelineCacheHeaderVersion)input_value)
45 {
46 case VK_PIPELINE_CACHE_HEADER_VERSION_ONE:
47 return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE";
48 default:
49 return "Unhandled VkPipelineCacheHeaderVersion";
50 }
51 }
52
string_VkResult(VkResult input_value)53 static inline const char* string_VkResult(VkResult input_value)
54 {
55 switch ((VkResult)input_value)
56 {
57 case VK_ERROR_DEVICE_LOST:
58 return "VK_ERROR_DEVICE_LOST";
59 case VK_ERROR_EXTENSION_NOT_PRESENT:
60 return "VK_ERROR_EXTENSION_NOT_PRESENT";
61 case VK_ERROR_FEATURE_NOT_PRESENT:
62 return "VK_ERROR_FEATURE_NOT_PRESENT";
63 case VK_ERROR_FORMAT_NOT_SUPPORTED:
64 return "VK_ERROR_FORMAT_NOT_SUPPORTED";
65 case VK_ERROR_FRAGMENTATION_EXT:
66 return "VK_ERROR_FRAGMENTATION_EXT";
67 case VK_ERROR_FRAGMENTED_POOL:
68 return "VK_ERROR_FRAGMENTED_POOL";
69 case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
70 return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
71 case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
72 return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
73 case VK_ERROR_INCOMPATIBLE_DRIVER:
74 return "VK_ERROR_INCOMPATIBLE_DRIVER";
75 case VK_ERROR_INITIALIZATION_FAILED:
76 return "VK_ERROR_INITIALIZATION_FAILED";
77 case VK_ERROR_INVALID_DEVICE_ADDRESS_EXT:
78 return "VK_ERROR_INVALID_DEVICE_ADDRESS_EXT";
79 case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
80 return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
81 case VK_ERROR_INVALID_EXTERNAL_HANDLE:
82 return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
83 case VK_ERROR_INVALID_SHADER_NV:
84 return "VK_ERROR_INVALID_SHADER_NV";
85 case VK_ERROR_LAYER_NOT_PRESENT:
86 return "VK_ERROR_LAYER_NOT_PRESENT";
87 case VK_ERROR_MEMORY_MAP_FAILED:
88 return "VK_ERROR_MEMORY_MAP_FAILED";
89 case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
90 return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
91 case VK_ERROR_NOT_PERMITTED_EXT:
92 return "VK_ERROR_NOT_PERMITTED_EXT";
93 case VK_ERROR_OUT_OF_DATE_KHR:
94 return "VK_ERROR_OUT_OF_DATE_KHR";
95 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
96 return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
97 case VK_ERROR_OUT_OF_HOST_MEMORY:
98 return "VK_ERROR_OUT_OF_HOST_MEMORY";
99 case VK_ERROR_OUT_OF_POOL_MEMORY:
100 return "VK_ERROR_OUT_OF_POOL_MEMORY";
101 case VK_ERROR_SURFACE_LOST_KHR:
102 return "VK_ERROR_SURFACE_LOST_KHR";
103 case VK_ERROR_TOO_MANY_OBJECTS:
104 return "VK_ERROR_TOO_MANY_OBJECTS";
105 case VK_ERROR_VALIDATION_FAILED_EXT:
106 return "VK_ERROR_VALIDATION_FAILED_EXT";
107 case VK_EVENT_RESET:
108 return "VK_EVENT_RESET";
109 case VK_EVENT_SET:
110 return "VK_EVENT_SET";
111 case VK_INCOMPLETE:
112 return "VK_INCOMPLETE";
113 case VK_NOT_READY:
114 return "VK_NOT_READY";
115 case VK_SUBOPTIMAL_KHR:
116 return "VK_SUBOPTIMAL_KHR";
117 case VK_SUCCESS:
118 return "VK_SUCCESS";
119 case VK_TIMEOUT:
120 return "VK_TIMEOUT";
121 default:
122 return "Unhandled VkResult";
123 }
124 }
125
string_VkStructureType(VkStructureType input_value)126 static inline const char* string_VkStructureType(VkStructureType input_value)
127 {
128 switch ((VkStructureType)input_value)
129 {
130 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
131 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV";
132 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
133 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV";
134 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
135 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV";
136 case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
137 return "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR";
138 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
139 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID";
140 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
141 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID";
142 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
143 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID";
144 case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
145 return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
146 case VK_STRUCTURE_TYPE_APPLICATION_INFO:
147 return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
148 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR:
149 return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR";
150 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR:
151 return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR";
152 case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
153 return "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV";
154 case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
155 return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO";
156 case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
157 return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO";
158 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
159 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO";
160 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
161 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO";
162 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
163 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR";
164 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
165 return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO";
166 case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
167 return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
168 case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
169 return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
170 case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
171 return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT";
172 case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT:
173 return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT";
174 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
175 return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
176 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
177 return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2";
178 case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
179 return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
180 case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT:
181 return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT";
182 case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
183 return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV";
184 case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX:
185 return "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX";
186 case VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX:
187 return "VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX";
188 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
189 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
190 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
191 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
192 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
193 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT";
194 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
195 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
196 case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
197 return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
198 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
199 return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
200 case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
201 return "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT";
202 case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
203 return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV";
204 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
205 return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
206 case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
207 return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR";
208 case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
209 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
210 case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
211 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
212 case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
213 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
214 case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
215 return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
216 case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
217 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT";
218 case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
219 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT";
220 case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
221 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT";
222 case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
223 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT";
224 case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
225 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT";
226 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
227 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
228 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
229 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
230 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
231 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
232 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
233 return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
234 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
235 return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT";
236 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
237 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
238 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
239 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT";
240 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
241 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
242 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
243 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT";
244 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
245 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT";
246 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
247 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT";
248 case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
249 return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO";
250 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
251 return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
252 case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
253 return "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT";
254 case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX:
255 return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX";
256 case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX:
257 return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX";
258 case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
259 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO";
260 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
261 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO";
262 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
263 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO";
264 case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
265 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR";
266 case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
267 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR";
268 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
269 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO";
270 case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
271 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO";
272 case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
273 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR";
274 case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
275 return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD";
276 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
277 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
278 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
279 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT";
280 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
281 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2";
282 case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
283 return "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT";
284 case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
285 return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
286 case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
287 return "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR";
288 case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
289 return "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD";
290 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
291 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR";
292 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
293 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR";
294 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
295 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR";
296 case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
297 return "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT";
298 case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
299 return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
300 case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
301 return "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR";
302 case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
303 return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
304 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
305 return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT";
306 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
307 return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT";
308 case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
309 return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
310 case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
311 return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO";
312 case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
313 return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR";
314 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
315 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO";
316 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
317 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
318 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
319 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
320 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
321 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
322 case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
323 return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO";
324 case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
325 return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
326 case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
327 return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES";
328 case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
329 return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES";
330 case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
331 return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID";
332 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
333 return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES";
334 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
335 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO";
336 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
337 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO";
338 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
339 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
340 case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
341 return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES";
342 case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
343 return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
344 case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
345 return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
346 case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
347 return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
348 case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
349 return "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT";
350 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
351 return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2";
352 case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR:
353 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR";
354 case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR:
355 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR";
356 case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
357 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
358 case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
359 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV";
360 case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
361 return "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV";
362 case VK_STRUCTURE_TYPE_GEOMETRY_NV:
363 return "VK_STRUCTURE_TYPE_GEOMETRY_NV";
364 case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
365 return "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV";
366 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
367 return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
368 case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
369 return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT";
370 case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
371 return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
372 case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
373 return "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA";
374 case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
375 return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
376 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
377 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT";
378 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
379 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT";
380 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
381 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT";
382 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
383 return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR";
384 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
385 return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2";
386 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
387 return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
388 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
389 return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2";
390 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
391 return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO";
392 case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
393 return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2";
394 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT:
395 return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT";
396 case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
397 return "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR";
398 case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
399 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT";
400 case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
401 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
402 case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
403 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX";
404 case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
405 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO";
406 case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
407 return "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
408 case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
409 return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
410 case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
411 return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR";
412 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
413 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
414 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
415 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT";
416 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
417 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
418 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
419 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
420 case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
421 return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
422 case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
423 return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
424 case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX:
425 return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
426 case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
427 return "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL";
428 case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
429 return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
430 case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
431 return "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK";
432 case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
433 return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
434 case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
435 return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
436 case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
437 return "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK";
438 case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
439 return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
440 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
441 return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO";
442 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
443 return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
444 case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
445 return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
446 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
447 return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO";
448 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
449 return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS";
450 case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
451 return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR";
452 case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
453 return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
454 case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
455 return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR";
456 case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
457 return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR";
458 case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
459 return "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT";
460 case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
461 return "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT";
462 case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
463 return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2";
464 case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
465 return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR";
466 case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
467 return "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT";
468 case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
469 return "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT";
470 case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX:
471 return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
472 case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
473 return "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL";
474 case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
475 return "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL";
476 case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
477 return "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL";
478 case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
479 return "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL";
480 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
481 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES";
482 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
483 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR";
484 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
485 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT";
486 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
487 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT";
488 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
489 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT";
490 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
491 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
492 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
493 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
494 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
495 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV";
496 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
497 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT";
498 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
499 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT";
500 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
501 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV";
502 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
503 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV";
504 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
505 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV";
506 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
507 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV";
508 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
509 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV";
510 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
511 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT";
512 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR:
513 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR";
514 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
515 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT";
516 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
517 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT";
518 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
519 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT";
520 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR:
521 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR";
522 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
523 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV";
524 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
525 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO";
526 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
527 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO";
528 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
529 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO";
530 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
531 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT";
532 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
533 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO";
534 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
535 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2";
536 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR:
537 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR";
538 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
539 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT";
540 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
541 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT";
542 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
543 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV";
544 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
545 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT";
546 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
547 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES";
548 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT:
549 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT";
550 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
551 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES";
552 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR:
553 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR";
554 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
555 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT";
556 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
557 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2";
558 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
559 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT";
560 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
561 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
562 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
563 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT";
564 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
565 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT";
566 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
567 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
568 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
569 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
570 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
571 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES";
572 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
573 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT";
574 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
575 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT";
576 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
577 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2";
578 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
579 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV";
580 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
581 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV";
582 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
583 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES";
584 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
585 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX";
586 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
587 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES";
588 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
589 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT";
590 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
591 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR";
592 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
593 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES";
594 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
595 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2";
596 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
597 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES";
598 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
599 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES";
600 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
601 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
603 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV";
604 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
605 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV";
606 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
607 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT";
608 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
609 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES";
610 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
611 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT";
612 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT:
613 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT";
614 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR:
615 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR";
616 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
617 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
618 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
619 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD";
620 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
621 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT";
622 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
623 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES";
624 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR:
625 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR";
626 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
627 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV";
628 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
629 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL";
630 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
631 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV";
632 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
633 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV";
634 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
635 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV";
636 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
637 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV";
638 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
639 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2";
640 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
641 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES";
642 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
643 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT";
644 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
645 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT";
646 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
647 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
648 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
649 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT";
650 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
651 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT";
652 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
653 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT";
654 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
655 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT";
656 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
657 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT";
658 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR:
659 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR";
660 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
661 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES";
662 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
663 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT";
664 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
665 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT";
666 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR:
667 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR";
668 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
669 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT";
670 case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
671 return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
672 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
673 return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT";
674 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
675 return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
676 case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
677 return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD";
678 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
679 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV";
680 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
681 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV";
682 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
683 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV";
684 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
685 return "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT";
686 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
687 return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
688 case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
689 return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT";
690 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
691 return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
692 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
693 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR";
694 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
695 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
696 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
697 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR";
698 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
699 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
700 case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
701 return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR";
702 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
703 return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
704 case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
705 return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
706 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
707 return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
708 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
709 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT";
710 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
711 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT";
712 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
713 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
714 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
715 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
716 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
717 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
718 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
719 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT";
720 case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
721 return "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV";
722 case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
723 return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT";
724 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
725 return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
726 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
727 return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT";
728 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
729 return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO";
730 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
731 return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
732 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
733 return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT";
734 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
735 return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
736 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
737 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV";
738 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
739 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV";
740 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
741 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV";
742 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
743 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
744 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
745 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV";
746 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
747 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV";
748 case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
749 return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP";
750 case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
751 return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
752 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
753 return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
754 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
755 return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
756 case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
757 return "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO";
758 case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
759 return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
760 case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL:
761 return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL";
762 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
763 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV";
764 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
765 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2";
766 case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
767 return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV";
768 case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
769 return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV";
770 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR:
771 return "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR";
772 case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
773 return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
774 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
775 return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
776 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR:
777 return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR";
778 case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
779 return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT";
780 case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
781 return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO";
782 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
783 return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO";
784 case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
785 return "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT";
786 case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
787 return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
788 case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
789 return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT";
790 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
791 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO";
792 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
793 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES";
794 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
795 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO";
796 case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
797 return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT";
798 case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
799 return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
800 case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
801 return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
802 case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
803 return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR";
804 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
805 return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
806 case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
807 return "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT";
808 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
809 return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
810 case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
811 return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2";
812 case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
813 return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2";
814 case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
815 return "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP";
816 case VK_STRUCTURE_TYPE_SUBMIT_INFO:
817 return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
818 case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR:
819 return "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR";
820 case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR:
821 return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR";
822 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR:
823 return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR";
824 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR:
825 return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR";
826 case VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR:
827 return "VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR";
828 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
829 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT";
830 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
831 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
832 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
833 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT";
834 case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
835 return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
836 case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
837 return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT";
838 case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
839 return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
840 case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
841 return "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR";
842 case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
843 return "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT";
844 case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
845 return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
846 case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
847 return "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD";
848 case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
849 return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
850 case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
851 return "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT";
852 case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
853 return "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT";
854 case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
855 return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
856 case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
857 return "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN";
858 case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
859 return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
860 case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
861 return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR";
862 case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
863 return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
864 case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
865 return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
866 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
867 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
868 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
869 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV";
870 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
871 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT";
872 case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
873 return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
874 case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
875 return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
876 default:
877 return "Unhandled VkStructureType";
878 }
879 }
880
string_VkSystemAllocationScope(VkSystemAllocationScope input_value)881 static inline const char* string_VkSystemAllocationScope(VkSystemAllocationScope input_value)
882 {
883 switch ((VkSystemAllocationScope)input_value)
884 {
885 case VK_SYSTEM_ALLOCATION_SCOPE_CACHE:
886 return "VK_SYSTEM_ALLOCATION_SCOPE_CACHE";
887 case VK_SYSTEM_ALLOCATION_SCOPE_COMMAND:
888 return "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND";
889 case VK_SYSTEM_ALLOCATION_SCOPE_DEVICE:
890 return "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE";
891 case VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE:
892 return "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE";
893 case VK_SYSTEM_ALLOCATION_SCOPE_OBJECT:
894 return "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT";
895 default:
896 return "Unhandled VkSystemAllocationScope";
897 }
898 }
899
string_VkInternalAllocationType(VkInternalAllocationType input_value)900 static inline const char* string_VkInternalAllocationType(VkInternalAllocationType input_value)
901 {
902 switch ((VkInternalAllocationType)input_value)
903 {
904 case VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE:
905 return "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE";
906 default:
907 return "Unhandled VkInternalAllocationType";
908 }
909 }
910
string_VkFormat(VkFormat input_value)911 static inline const char* string_VkFormat(VkFormat input_value)
912 {
913 switch ((VkFormat)input_value)
914 {
915 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
916 return "VK_FORMAT_A1R5G5B5_UNORM_PACK16";
917 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
918 return "VK_FORMAT_A2B10G10R10_SINT_PACK32";
919 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
920 return "VK_FORMAT_A2B10G10R10_SNORM_PACK32";
921 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
922 return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32";
923 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
924 return "VK_FORMAT_A2B10G10R10_UINT_PACK32";
925 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
926 return "VK_FORMAT_A2B10G10R10_UNORM_PACK32";
927 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
928 return "VK_FORMAT_A2B10G10R10_USCALED_PACK32";
929 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
930 return "VK_FORMAT_A2R10G10B10_SINT_PACK32";
931 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
932 return "VK_FORMAT_A2R10G10B10_SNORM_PACK32";
933 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
934 return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32";
935 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
936 return "VK_FORMAT_A2R10G10B10_UINT_PACK32";
937 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
938 return "VK_FORMAT_A2R10G10B10_UNORM_PACK32";
939 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
940 return "VK_FORMAT_A2R10G10B10_USCALED_PACK32";
941 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
942 return "VK_FORMAT_A8B8G8R8_SINT_PACK32";
943 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
944 return "VK_FORMAT_A8B8G8R8_SNORM_PACK32";
945 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
946 return "VK_FORMAT_A8B8G8R8_SRGB_PACK32";
947 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
948 return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32";
949 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
950 return "VK_FORMAT_A8B8G8R8_UINT_PACK32";
951 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
952 return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
953 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
954 return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
955 case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT:
956 return "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT";
957 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
958 return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
959 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
960 return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
961 case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT:
962 return "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT";
963 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
964 return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
965 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
966 return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
967 case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT:
968 return "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT";
969 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
970 return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
971 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
972 return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
973 case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT:
974 return "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT";
975 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
976 return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
977 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
978 return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
979 case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT:
980 return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT";
981 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
982 return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
983 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
984 return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
985 case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT:
986 return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT";
987 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
988 return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
989 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
990 return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
991 case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT:
992 return "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT";
993 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
994 return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
995 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
996 return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
997 case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT:
998 return "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT";
999 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1000 return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
1001 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1002 return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
1003 case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT:
1004 return "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT";
1005 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1006 return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
1007 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1008 return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
1009 case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT:
1010 return "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT";
1011 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1012 return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
1013 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1014 return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
1015 case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT:
1016 return "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT";
1017 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1018 return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
1019 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1020 return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
1021 case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT:
1022 return "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT";
1023 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1024 return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
1025 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1026 return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
1027 case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT:
1028 return "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT";
1029 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1030 return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
1031 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1032 return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
1033 case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT:
1034 return "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT";
1035 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1036 return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
1037 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1038 return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK";
1039 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1040 return "VK_FORMAT_B10G11R11_UFLOAT_PACK32";
1041 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
1042 return "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
1043 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
1044 return "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
1045 case VK_FORMAT_B16G16R16G16_422_UNORM:
1046 return "VK_FORMAT_B16G16R16G16_422_UNORM";
1047 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1048 return "VK_FORMAT_B4G4R4A4_UNORM_PACK16";
1049 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1050 return "VK_FORMAT_B5G5R5A1_UNORM_PACK16";
1051 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1052 return "VK_FORMAT_B5G6R5_UNORM_PACK16";
1053 case VK_FORMAT_B8G8R8A8_SINT:
1054 return "VK_FORMAT_B8G8R8A8_SINT";
1055 case VK_FORMAT_B8G8R8A8_SNORM:
1056 return "VK_FORMAT_B8G8R8A8_SNORM";
1057 case VK_FORMAT_B8G8R8A8_SRGB:
1058 return "VK_FORMAT_B8G8R8A8_SRGB";
1059 case VK_FORMAT_B8G8R8A8_SSCALED:
1060 return "VK_FORMAT_B8G8R8A8_SSCALED";
1061 case VK_FORMAT_B8G8R8A8_UINT:
1062 return "VK_FORMAT_B8G8R8A8_UINT";
1063 case VK_FORMAT_B8G8R8A8_UNORM:
1064 return "VK_FORMAT_B8G8R8A8_UNORM";
1065 case VK_FORMAT_B8G8R8A8_USCALED:
1066 return "VK_FORMAT_B8G8R8A8_USCALED";
1067 case VK_FORMAT_B8G8R8G8_422_UNORM:
1068 return "VK_FORMAT_B8G8R8G8_422_UNORM";
1069 case VK_FORMAT_B8G8R8_SINT:
1070 return "VK_FORMAT_B8G8R8_SINT";
1071 case VK_FORMAT_B8G8R8_SNORM:
1072 return "VK_FORMAT_B8G8R8_SNORM";
1073 case VK_FORMAT_B8G8R8_SRGB:
1074 return "VK_FORMAT_B8G8R8_SRGB";
1075 case VK_FORMAT_B8G8R8_SSCALED:
1076 return "VK_FORMAT_B8G8R8_SSCALED";
1077 case VK_FORMAT_B8G8R8_UINT:
1078 return "VK_FORMAT_B8G8R8_UINT";
1079 case VK_FORMAT_B8G8R8_UNORM:
1080 return "VK_FORMAT_B8G8R8_UNORM";
1081 case VK_FORMAT_B8G8R8_USCALED:
1082 return "VK_FORMAT_B8G8R8_USCALED";
1083 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1084 return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK";
1085 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1086 return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK";
1087 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1088 return "VK_FORMAT_BC1_RGB_SRGB_BLOCK";
1089 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1090 return "VK_FORMAT_BC1_RGB_UNORM_BLOCK";
1091 case VK_FORMAT_BC2_SRGB_BLOCK:
1092 return "VK_FORMAT_BC2_SRGB_BLOCK";
1093 case VK_FORMAT_BC2_UNORM_BLOCK:
1094 return "VK_FORMAT_BC2_UNORM_BLOCK";
1095 case VK_FORMAT_BC3_SRGB_BLOCK:
1096 return "VK_FORMAT_BC3_SRGB_BLOCK";
1097 case VK_FORMAT_BC3_UNORM_BLOCK:
1098 return "VK_FORMAT_BC3_UNORM_BLOCK";
1099 case VK_FORMAT_BC4_SNORM_BLOCK:
1100 return "VK_FORMAT_BC4_SNORM_BLOCK";
1101 case VK_FORMAT_BC4_UNORM_BLOCK:
1102 return "VK_FORMAT_BC4_UNORM_BLOCK";
1103 case VK_FORMAT_BC5_SNORM_BLOCK:
1104 return "VK_FORMAT_BC5_SNORM_BLOCK";
1105 case VK_FORMAT_BC5_UNORM_BLOCK:
1106 return "VK_FORMAT_BC5_UNORM_BLOCK";
1107 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1108 return "VK_FORMAT_BC6H_SFLOAT_BLOCK";
1109 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1110 return "VK_FORMAT_BC6H_UFLOAT_BLOCK";
1111 case VK_FORMAT_BC7_SRGB_BLOCK:
1112 return "VK_FORMAT_BC7_SRGB_BLOCK";
1113 case VK_FORMAT_BC7_UNORM_BLOCK:
1114 return "VK_FORMAT_BC7_UNORM_BLOCK";
1115 case VK_FORMAT_D16_UNORM:
1116 return "VK_FORMAT_D16_UNORM";
1117 case VK_FORMAT_D16_UNORM_S8_UINT:
1118 return "VK_FORMAT_D16_UNORM_S8_UINT";
1119 case VK_FORMAT_D24_UNORM_S8_UINT:
1120 return "VK_FORMAT_D24_UNORM_S8_UINT";
1121 case VK_FORMAT_D32_SFLOAT:
1122 return "VK_FORMAT_D32_SFLOAT";
1123 case VK_FORMAT_D32_SFLOAT_S8_UINT:
1124 return "VK_FORMAT_D32_SFLOAT_S8_UINT";
1125 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1126 return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32";
1127 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1128 return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK";
1129 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1130 return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK";
1131 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1132 return "VK_FORMAT_EAC_R11_SNORM_BLOCK";
1133 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1134 return "VK_FORMAT_EAC_R11_UNORM_BLOCK";
1135 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1136 return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
1137 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1138 return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
1139 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1140 return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
1141 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1142 return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
1143 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1144 return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
1145 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1146 return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
1147 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
1148 return "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
1149 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
1150 return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
1151 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
1152 return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
1153 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
1154 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
1155 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
1156 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
1157 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
1158 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
1159 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
1160 return "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
1161 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
1162 return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
1163 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
1164 return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
1165 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
1166 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
1167 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
1168 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
1169 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
1170 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
1171 case VK_FORMAT_G16B16G16R16_422_UNORM:
1172 return "VK_FORMAT_G16B16G16R16_422_UNORM";
1173 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
1174 return "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM";
1175 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
1176 return "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM";
1177 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
1178 return "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM";
1179 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
1180 return "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM";
1181 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
1182 return "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM";
1183 case VK_FORMAT_G8B8G8R8_422_UNORM:
1184 return "VK_FORMAT_G8B8G8R8_422_UNORM";
1185 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
1186 return "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM";
1187 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
1188 return "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM";
1189 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
1190 return "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM";
1191 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
1192 return "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM";
1193 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
1194 return "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM";
1195 case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
1196 return "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
1197 case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
1198 return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
1199 case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
1200 return "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
1201 case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
1202 return "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
1203 case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
1204 return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
1205 case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
1206 return "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
1207 case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
1208 return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
1209 case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
1210 return "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
1211 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
1212 return "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
1213 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
1214 return "VK_FORMAT_R10X6G10X6_UNORM_2PACK16";
1215 case VK_FORMAT_R10X6_UNORM_PACK16:
1216 return "VK_FORMAT_R10X6_UNORM_PACK16";
1217 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
1218 return "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
1219 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
1220 return "VK_FORMAT_R12X4G12X4_UNORM_2PACK16";
1221 case VK_FORMAT_R12X4_UNORM_PACK16:
1222 return "VK_FORMAT_R12X4_UNORM_PACK16";
1223 case VK_FORMAT_R16G16B16A16_SFLOAT:
1224 return "VK_FORMAT_R16G16B16A16_SFLOAT";
1225 case VK_FORMAT_R16G16B16A16_SINT:
1226 return "VK_FORMAT_R16G16B16A16_SINT";
1227 case VK_FORMAT_R16G16B16A16_SNORM:
1228 return "VK_FORMAT_R16G16B16A16_SNORM";
1229 case VK_FORMAT_R16G16B16A16_SSCALED:
1230 return "VK_FORMAT_R16G16B16A16_SSCALED";
1231 case VK_FORMAT_R16G16B16A16_UINT:
1232 return "VK_FORMAT_R16G16B16A16_UINT";
1233 case VK_FORMAT_R16G16B16A16_UNORM:
1234 return "VK_FORMAT_R16G16B16A16_UNORM";
1235 case VK_FORMAT_R16G16B16A16_USCALED:
1236 return "VK_FORMAT_R16G16B16A16_USCALED";
1237 case VK_FORMAT_R16G16B16_SFLOAT:
1238 return "VK_FORMAT_R16G16B16_SFLOAT";
1239 case VK_FORMAT_R16G16B16_SINT:
1240 return "VK_FORMAT_R16G16B16_SINT";
1241 case VK_FORMAT_R16G16B16_SNORM:
1242 return "VK_FORMAT_R16G16B16_SNORM";
1243 case VK_FORMAT_R16G16B16_SSCALED:
1244 return "VK_FORMAT_R16G16B16_SSCALED";
1245 case VK_FORMAT_R16G16B16_UINT:
1246 return "VK_FORMAT_R16G16B16_UINT";
1247 case VK_FORMAT_R16G16B16_UNORM:
1248 return "VK_FORMAT_R16G16B16_UNORM";
1249 case VK_FORMAT_R16G16B16_USCALED:
1250 return "VK_FORMAT_R16G16B16_USCALED";
1251 case VK_FORMAT_R16G16_SFLOAT:
1252 return "VK_FORMAT_R16G16_SFLOAT";
1253 case VK_FORMAT_R16G16_SINT:
1254 return "VK_FORMAT_R16G16_SINT";
1255 case VK_FORMAT_R16G16_SNORM:
1256 return "VK_FORMAT_R16G16_SNORM";
1257 case VK_FORMAT_R16G16_SSCALED:
1258 return "VK_FORMAT_R16G16_SSCALED";
1259 case VK_FORMAT_R16G16_UINT:
1260 return "VK_FORMAT_R16G16_UINT";
1261 case VK_FORMAT_R16G16_UNORM:
1262 return "VK_FORMAT_R16G16_UNORM";
1263 case VK_FORMAT_R16G16_USCALED:
1264 return "VK_FORMAT_R16G16_USCALED";
1265 case VK_FORMAT_R16_SFLOAT:
1266 return "VK_FORMAT_R16_SFLOAT";
1267 case VK_FORMAT_R16_SINT:
1268 return "VK_FORMAT_R16_SINT";
1269 case VK_FORMAT_R16_SNORM:
1270 return "VK_FORMAT_R16_SNORM";
1271 case VK_FORMAT_R16_SSCALED:
1272 return "VK_FORMAT_R16_SSCALED";
1273 case VK_FORMAT_R16_UINT:
1274 return "VK_FORMAT_R16_UINT";
1275 case VK_FORMAT_R16_UNORM:
1276 return "VK_FORMAT_R16_UNORM";
1277 case VK_FORMAT_R16_USCALED:
1278 return "VK_FORMAT_R16_USCALED";
1279 case VK_FORMAT_R32G32B32A32_SFLOAT:
1280 return "VK_FORMAT_R32G32B32A32_SFLOAT";
1281 case VK_FORMAT_R32G32B32A32_SINT:
1282 return "VK_FORMAT_R32G32B32A32_SINT";
1283 case VK_FORMAT_R32G32B32A32_UINT:
1284 return "VK_FORMAT_R32G32B32A32_UINT";
1285 case VK_FORMAT_R32G32B32_SFLOAT:
1286 return "VK_FORMAT_R32G32B32_SFLOAT";
1287 case VK_FORMAT_R32G32B32_SINT:
1288 return "VK_FORMAT_R32G32B32_SINT";
1289 case VK_FORMAT_R32G32B32_UINT:
1290 return "VK_FORMAT_R32G32B32_UINT";
1291 case VK_FORMAT_R32G32_SFLOAT:
1292 return "VK_FORMAT_R32G32_SFLOAT";
1293 case VK_FORMAT_R32G32_SINT:
1294 return "VK_FORMAT_R32G32_SINT";
1295 case VK_FORMAT_R32G32_UINT:
1296 return "VK_FORMAT_R32G32_UINT";
1297 case VK_FORMAT_R32_SFLOAT:
1298 return "VK_FORMAT_R32_SFLOAT";
1299 case VK_FORMAT_R32_SINT:
1300 return "VK_FORMAT_R32_SINT";
1301 case VK_FORMAT_R32_UINT:
1302 return "VK_FORMAT_R32_UINT";
1303 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1304 return "VK_FORMAT_R4G4B4A4_UNORM_PACK16";
1305 case VK_FORMAT_R4G4_UNORM_PACK8:
1306 return "VK_FORMAT_R4G4_UNORM_PACK8";
1307 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1308 return "VK_FORMAT_R5G5B5A1_UNORM_PACK16";
1309 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1310 return "VK_FORMAT_R5G6B5_UNORM_PACK16";
1311 case VK_FORMAT_R64G64B64A64_SFLOAT:
1312 return "VK_FORMAT_R64G64B64A64_SFLOAT";
1313 case VK_FORMAT_R64G64B64A64_SINT:
1314 return "VK_FORMAT_R64G64B64A64_SINT";
1315 case VK_FORMAT_R64G64B64A64_UINT:
1316 return "VK_FORMAT_R64G64B64A64_UINT";
1317 case VK_FORMAT_R64G64B64_SFLOAT:
1318 return "VK_FORMAT_R64G64B64_SFLOAT";
1319 case VK_FORMAT_R64G64B64_SINT:
1320 return "VK_FORMAT_R64G64B64_SINT";
1321 case VK_FORMAT_R64G64B64_UINT:
1322 return "VK_FORMAT_R64G64B64_UINT";
1323 case VK_FORMAT_R64G64_SFLOAT:
1324 return "VK_FORMAT_R64G64_SFLOAT";
1325 case VK_FORMAT_R64G64_SINT:
1326 return "VK_FORMAT_R64G64_SINT";
1327 case VK_FORMAT_R64G64_UINT:
1328 return "VK_FORMAT_R64G64_UINT";
1329 case VK_FORMAT_R64_SFLOAT:
1330 return "VK_FORMAT_R64_SFLOAT";
1331 case VK_FORMAT_R64_SINT:
1332 return "VK_FORMAT_R64_SINT";
1333 case VK_FORMAT_R64_UINT:
1334 return "VK_FORMAT_R64_UINT";
1335 case VK_FORMAT_R8G8B8A8_SINT:
1336 return "VK_FORMAT_R8G8B8A8_SINT";
1337 case VK_FORMAT_R8G8B8A8_SNORM:
1338 return "VK_FORMAT_R8G8B8A8_SNORM";
1339 case VK_FORMAT_R8G8B8A8_SRGB:
1340 return "VK_FORMAT_R8G8B8A8_SRGB";
1341 case VK_FORMAT_R8G8B8A8_SSCALED:
1342 return "VK_FORMAT_R8G8B8A8_SSCALED";
1343 case VK_FORMAT_R8G8B8A8_UINT:
1344 return "VK_FORMAT_R8G8B8A8_UINT";
1345 case VK_FORMAT_R8G8B8A8_UNORM:
1346 return "VK_FORMAT_R8G8B8A8_UNORM";
1347 case VK_FORMAT_R8G8B8A8_USCALED:
1348 return "VK_FORMAT_R8G8B8A8_USCALED";
1349 case VK_FORMAT_R8G8B8_SINT:
1350 return "VK_FORMAT_R8G8B8_SINT";
1351 case VK_FORMAT_R8G8B8_SNORM:
1352 return "VK_FORMAT_R8G8B8_SNORM";
1353 case VK_FORMAT_R8G8B8_SRGB:
1354 return "VK_FORMAT_R8G8B8_SRGB";
1355 case VK_FORMAT_R8G8B8_SSCALED:
1356 return "VK_FORMAT_R8G8B8_SSCALED";
1357 case VK_FORMAT_R8G8B8_UINT:
1358 return "VK_FORMAT_R8G8B8_UINT";
1359 case VK_FORMAT_R8G8B8_UNORM:
1360 return "VK_FORMAT_R8G8B8_UNORM";
1361 case VK_FORMAT_R8G8B8_USCALED:
1362 return "VK_FORMAT_R8G8B8_USCALED";
1363 case VK_FORMAT_R8G8_SINT:
1364 return "VK_FORMAT_R8G8_SINT";
1365 case VK_FORMAT_R8G8_SNORM:
1366 return "VK_FORMAT_R8G8_SNORM";
1367 case VK_FORMAT_R8G8_SRGB:
1368 return "VK_FORMAT_R8G8_SRGB";
1369 case VK_FORMAT_R8G8_SSCALED:
1370 return "VK_FORMAT_R8G8_SSCALED";
1371 case VK_FORMAT_R8G8_UINT:
1372 return "VK_FORMAT_R8G8_UINT";
1373 case VK_FORMAT_R8G8_UNORM:
1374 return "VK_FORMAT_R8G8_UNORM";
1375 case VK_FORMAT_R8G8_USCALED:
1376 return "VK_FORMAT_R8G8_USCALED";
1377 case VK_FORMAT_R8_SINT:
1378 return "VK_FORMAT_R8_SINT";
1379 case VK_FORMAT_R8_SNORM:
1380 return "VK_FORMAT_R8_SNORM";
1381 case VK_FORMAT_R8_SRGB:
1382 return "VK_FORMAT_R8_SRGB";
1383 case VK_FORMAT_R8_SSCALED:
1384 return "VK_FORMAT_R8_SSCALED";
1385 case VK_FORMAT_R8_UINT:
1386 return "VK_FORMAT_R8_UINT";
1387 case VK_FORMAT_R8_UNORM:
1388 return "VK_FORMAT_R8_UNORM";
1389 case VK_FORMAT_R8_USCALED:
1390 return "VK_FORMAT_R8_USCALED";
1391 case VK_FORMAT_S8_UINT:
1392 return "VK_FORMAT_S8_UINT";
1393 case VK_FORMAT_UNDEFINED:
1394 return "VK_FORMAT_UNDEFINED";
1395 case VK_FORMAT_X8_D24_UNORM_PACK32:
1396 return "VK_FORMAT_X8_D24_UNORM_PACK32";
1397 default:
1398 return "Unhandled VkFormat";
1399 }
1400 }
1401
string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value)1402 static inline const char* string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value)
1403 {
1404 switch ((VkFormatFeatureFlagBits)input_value)
1405 {
1406 case VK_FORMAT_FEATURE_BLIT_DST_BIT:
1407 return "VK_FORMAT_FEATURE_BLIT_DST_BIT";
1408 case VK_FORMAT_FEATURE_BLIT_SRC_BIT:
1409 return "VK_FORMAT_FEATURE_BLIT_SRC_BIT";
1410 case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT:
1411 return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT";
1412 case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT:
1413 return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT";
1414 case VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT:
1415 return "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT";
1416 case VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT:
1417 return "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT";
1418 case VK_FORMAT_FEATURE_DISJOINT_BIT:
1419 return "VK_FORMAT_FEATURE_DISJOINT_BIT";
1420 case VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT:
1421 return "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT";
1422 case VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT:
1423 return "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT";
1424 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT:
1425 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT";
1426 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG:
1427 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG";
1428 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT:
1429 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
1430 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT:
1431 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT";
1432 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT:
1433 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
1434 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT:
1435 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
1436 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT:
1437 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
1438 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT:
1439 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
1440 case VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT:
1441 return "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT";
1442 case VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT:
1443 return "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT";
1444 case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT:
1445 return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
1446 case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT:
1447 return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT";
1448 case VK_FORMAT_FEATURE_TRANSFER_DST_BIT:
1449 return "VK_FORMAT_FEATURE_TRANSFER_DST_BIT";
1450 case VK_FORMAT_FEATURE_TRANSFER_SRC_BIT:
1451 return "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT";
1452 case VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT:
1453 return "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT";
1454 case VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT:
1455 return "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT";
1456 default:
1457 return "Unhandled VkFormatFeatureFlagBits";
1458 }
1459 }
1460
string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value)1461 static inline std::string string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value)
1462 {
1463 std::string ret;
1464 int index = 0;
1465 while(input_value) {
1466 if (input_value & 1) {
1467 if( !ret.empty()) ret.append("|");
1468 ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(1 << index)));
1469 }
1470 ++index;
1471 input_value >>= 1;
1472 }
1473 if( ret.empty()) ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(0)));
1474 return ret;
1475 }
1476
string_VkImageType(VkImageType input_value)1477 static inline const char* string_VkImageType(VkImageType input_value)
1478 {
1479 switch ((VkImageType)input_value)
1480 {
1481 case VK_IMAGE_TYPE_1D:
1482 return "VK_IMAGE_TYPE_1D";
1483 case VK_IMAGE_TYPE_2D:
1484 return "VK_IMAGE_TYPE_2D";
1485 case VK_IMAGE_TYPE_3D:
1486 return "VK_IMAGE_TYPE_3D";
1487 default:
1488 return "Unhandled VkImageType";
1489 }
1490 }
1491
string_VkImageTiling(VkImageTiling input_value)1492 static inline const char* string_VkImageTiling(VkImageTiling input_value)
1493 {
1494 switch ((VkImageTiling)input_value)
1495 {
1496 case VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT:
1497 return "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
1498 case VK_IMAGE_TILING_LINEAR:
1499 return "VK_IMAGE_TILING_LINEAR";
1500 case VK_IMAGE_TILING_OPTIMAL:
1501 return "VK_IMAGE_TILING_OPTIMAL";
1502 default:
1503 return "Unhandled VkImageTiling";
1504 }
1505 }
1506
string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)1507 static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)
1508 {
1509 switch ((VkImageUsageFlagBits)input_value)
1510 {
1511 case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
1512 return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
1513 case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
1514 return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
1515 case VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT:
1516 return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT";
1517 case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
1518 return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
1519 case VK_IMAGE_USAGE_SAMPLED_BIT:
1520 return "VK_IMAGE_USAGE_SAMPLED_BIT";
1521 case VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV:
1522 return "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV";
1523 case VK_IMAGE_USAGE_STORAGE_BIT:
1524 return "VK_IMAGE_USAGE_STORAGE_BIT";
1525 case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
1526 return "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
1527 case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
1528 return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
1529 case VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT:
1530 return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
1531 default:
1532 return "Unhandled VkImageUsageFlagBits";
1533 }
1534 }
1535
string_VkImageUsageFlags(VkImageUsageFlags input_value)1536 static inline std::string string_VkImageUsageFlags(VkImageUsageFlags input_value)
1537 {
1538 std::string ret;
1539 int index = 0;
1540 while(input_value) {
1541 if (input_value & 1) {
1542 if( !ret.empty()) ret.append("|");
1543 ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(1 << index)));
1544 }
1545 ++index;
1546 input_value >>= 1;
1547 }
1548 if( ret.empty()) ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(0)));
1549 return ret;
1550 }
1551
string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)1552 static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)
1553 {
1554 switch ((VkImageCreateFlagBits)input_value)
1555 {
1556 case VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT:
1557 return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT";
1558 case VK_IMAGE_CREATE_ALIAS_BIT:
1559 return "VK_IMAGE_CREATE_ALIAS_BIT";
1560 case VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT:
1561 return "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT";
1562 case VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV:
1563 return "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV";
1564 case VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
1565 return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT";
1566 case VK_IMAGE_CREATE_DISJOINT_BIT:
1567 return "VK_IMAGE_CREATE_DISJOINT_BIT";
1568 case VK_IMAGE_CREATE_EXTENDED_USAGE_BIT:
1569 return "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT";
1570 case VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
1571 return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
1572 case VK_IMAGE_CREATE_PROTECTED_BIT:
1573 return "VK_IMAGE_CREATE_PROTECTED_BIT";
1574 case VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT:
1575 return "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT";
1576 case VK_IMAGE_CREATE_SPARSE_ALIASED_BIT:
1577 return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT";
1578 case VK_IMAGE_CREATE_SPARSE_BINDING_BIT:
1579 return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT";
1580 case VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT:
1581 return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT";
1582 case VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT:
1583 return "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT";
1584 case VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT:
1585 return "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT";
1586 default:
1587 return "Unhandled VkImageCreateFlagBits";
1588 }
1589 }
1590
string_VkImageCreateFlags(VkImageCreateFlags input_value)1591 static inline std::string string_VkImageCreateFlags(VkImageCreateFlags input_value)
1592 {
1593 std::string ret;
1594 int index = 0;
1595 while(input_value) {
1596 if (input_value & 1) {
1597 if( !ret.empty()) ret.append("|");
1598 ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(1 << index)));
1599 }
1600 ++index;
1601 input_value >>= 1;
1602 }
1603 if( ret.empty()) ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(0)));
1604 return ret;
1605 }
1606
string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)1607 static inline const char* string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)
1608 {
1609 switch ((VkSampleCountFlagBits)input_value)
1610 {
1611 case VK_SAMPLE_COUNT_16_BIT:
1612 return "VK_SAMPLE_COUNT_16_BIT";
1613 case VK_SAMPLE_COUNT_1_BIT:
1614 return "VK_SAMPLE_COUNT_1_BIT";
1615 case VK_SAMPLE_COUNT_2_BIT:
1616 return "VK_SAMPLE_COUNT_2_BIT";
1617 case VK_SAMPLE_COUNT_32_BIT:
1618 return "VK_SAMPLE_COUNT_32_BIT";
1619 case VK_SAMPLE_COUNT_4_BIT:
1620 return "VK_SAMPLE_COUNT_4_BIT";
1621 case VK_SAMPLE_COUNT_64_BIT:
1622 return "VK_SAMPLE_COUNT_64_BIT";
1623 case VK_SAMPLE_COUNT_8_BIT:
1624 return "VK_SAMPLE_COUNT_8_BIT";
1625 default:
1626 return "Unhandled VkSampleCountFlagBits";
1627 }
1628 }
1629
string_VkSampleCountFlags(VkSampleCountFlags input_value)1630 static inline std::string string_VkSampleCountFlags(VkSampleCountFlags input_value)
1631 {
1632 std::string ret;
1633 int index = 0;
1634 while(input_value) {
1635 if (input_value & 1) {
1636 if( !ret.empty()) ret.append("|");
1637 ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(1 << index)));
1638 }
1639 ++index;
1640 input_value >>= 1;
1641 }
1642 if( ret.empty()) ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(0)));
1643 return ret;
1644 }
1645
string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)1646 static inline const char* string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)
1647 {
1648 switch ((VkPhysicalDeviceType)input_value)
1649 {
1650 case VK_PHYSICAL_DEVICE_TYPE_CPU:
1651 return "VK_PHYSICAL_DEVICE_TYPE_CPU";
1652 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
1653 return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
1654 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
1655 return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
1656 case VK_PHYSICAL_DEVICE_TYPE_OTHER:
1657 return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
1658 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
1659 return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
1660 default:
1661 return "Unhandled VkPhysicalDeviceType";
1662 }
1663 }
1664
string_VkQueueFlagBits(VkQueueFlagBits input_value)1665 static inline const char* string_VkQueueFlagBits(VkQueueFlagBits input_value)
1666 {
1667 switch ((VkQueueFlagBits)input_value)
1668 {
1669 case VK_QUEUE_COMPUTE_BIT:
1670 return "VK_QUEUE_COMPUTE_BIT";
1671 case VK_QUEUE_GRAPHICS_BIT:
1672 return "VK_QUEUE_GRAPHICS_BIT";
1673 case VK_QUEUE_PROTECTED_BIT:
1674 return "VK_QUEUE_PROTECTED_BIT";
1675 case VK_QUEUE_SPARSE_BINDING_BIT:
1676 return "VK_QUEUE_SPARSE_BINDING_BIT";
1677 case VK_QUEUE_TRANSFER_BIT:
1678 return "VK_QUEUE_TRANSFER_BIT";
1679 default:
1680 return "Unhandled VkQueueFlagBits";
1681 }
1682 }
1683
string_VkQueueFlags(VkQueueFlags input_value)1684 static inline std::string string_VkQueueFlags(VkQueueFlags input_value)
1685 {
1686 std::string ret;
1687 int index = 0;
1688 while(input_value) {
1689 if (input_value & 1) {
1690 if( !ret.empty()) ret.append("|");
1691 ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(1 << index)));
1692 }
1693 ++index;
1694 input_value >>= 1;
1695 }
1696 if( ret.empty()) ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(0)));
1697 return ret;
1698 }
1699
string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)1700 static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)
1701 {
1702 switch ((VkMemoryPropertyFlagBits)input_value)
1703 {
1704 case VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD:
1705 return "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD";
1706 case VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT:
1707 return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
1708 case VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD:
1709 return "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD";
1710 case VK_MEMORY_PROPERTY_HOST_CACHED_BIT:
1711 return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
1712 case VK_MEMORY_PROPERTY_HOST_COHERENT_BIT:
1713 return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT";
1714 case VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT:
1715 return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT";
1716 case VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT:
1717 return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT";
1718 case VK_MEMORY_PROPERTY_PROTECTED_BIT:
1719 return "VK_MEMORY_PROPERTY_PROTECTED_BIT";
1720 default:
1721 return "Unhandled VkMemoryPropertyFlagBits";
1722 }
1723 }
1724
string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value)1725 static inline std::string string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value)
1726 {
1727 std::string ret;
1728 int index = 0;
1729 while(input_value) {
1730 if (input_value & 1) {
1731 if( !ret.empty()) ret.append("|");
1732 ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(1 << index)));
1733 }
1734 ++index;
1735 input_value >>= 1;
1736 }
1737 if( ret.empty()) ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(0)));
1738 return ret;
1739 }
1740
string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)1741 static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)
1742 {
1743 switch ((VkMemoryHeapFlagBits)input_value)
1744 {
1745 case VK_MEMORY_HEAP_DEVICE_LOCAL_BIT:
1746 return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
1747 case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT:
1748 return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
1749 default:
1750 return "Unhandled VkMemoryHeapFlagBits";
1751 }
1752 }
1753
string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value)1754 static inline std::string string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value)
1755 {
1756 std::string ret;
1757 int index = 0;
1758 while(input_value) {
1759 if (input_value & 1) {
1760 if( !ret.empty()) ret.append("|");
1761 ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(1 << index)));
1762 }
1763 ++index;
1764 input_value >>= 1;
1765 }
1766 if( ret.empty()) ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(0)));
1767 return ret;
1768 }
1769
string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value)1770 static inline const char* string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value)
1771 {
1772 switch ((VkDeviceQueueCreateFlagBits)input_value)
1773 {
1774 case VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT:
1775 return "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT";
1776 default:
1777 return "Unhandled VkDeviceQueueCreateFlagBits";
1778 }
1779 }
1780
string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value)1781 static inline std::string string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value)
1782 {
1783 std::string ret;
1784 int index = 0;
1785 while(input_value) {
1786 if (input_value & 1) {
1787 if( !ret.empty()) ret.append("|");
1788 ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(1 << index)));
1789 }
1790 ++index;
1791 input_value >>= 1;
1792 }
1793 if( ret.empty()) ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(0)));
1794 return ret;
1795 }
1796
string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)1797 static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)
1798 {
1799 switch ((VkPipelineStageFlagBits)input_value)
1800 {
1801 case VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV:
1802 return "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV";
1803 case VK_PIPELINE_STAGE_ALL_COMMANDS_BIT:
1804 return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT";
1805 case VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
1806 return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT";
1807 case VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
1808 return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT";
1809 case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
1810 return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT";
1811 case VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX:
1812 return "VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX";
1813 case VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
1814 return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT";
1815 case VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT:
1816 return "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT";
1817 case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
1818 return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT";
1819 case VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
1820 return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT";
1821 case VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
1822 return "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
1823 case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
1824 return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT";
1825 case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
1826 return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT";
1827 case VK_PIPELINE_STAGE_HOST_BIT:
1828 return "VK_PIPELINE_STAGE_HOST_BIT";
1829 case VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
1830 return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT";
1831 case VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV:
1832 return "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV";
1833 case VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV:
1834 return "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV";
1835 case VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV:
1836 return "VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV";
1837 case VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV:
1838 return "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV";
1839 case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
1840 return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT";
1841 case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
1842 return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT";
1843 case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
1844 return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT";
1845 case VK_PIPELINE_STAGE_TRANSFER_BIT:
1846 return "VK_PIPELINE_STAGE_TRANSFER_BIT";
1847 case VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT:
1848 return "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT";
1849 case VK_PIPELINE_STAGE_VERTEX_INPUT_BIT:
1850 return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT";
1851 case VK_PIPELINE_STAGE_VERTEX_SHADER_BIT:
1852 return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT";
1853 default:
1854 return "Unhandled VkPipelineStageFlagBits";
1855 }
1856 }
1857
string_VkPipelineStageFlags(VkPipelineStageFlags input_value)1858 static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input_value)
1859 {
1860 std::string ret;
1861 int index = 0;
1862 while(input_value) {
1863 if (input_value & 1) {
1864 if( !ret.empty()) ret.append("|");
1865 ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(1 << index)));
1866 }
1867 ++index;
1868 input_value >>= 1;
1869 }
1870 if( ret.empty()) ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(0)));
1871 return ret;
1872 }
1873
string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)1874 static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)
1875 {
1876 switch ((VkImageAspectFlagBits)input_value)
1877 {
1878 case VK_IMAGE_ASPECT_COLOR_BIT:
1879 return "VK_IMAGE_ASPECT_COLOR_BIT";
1880 case VK_IMAGE_ASPECT_DEPTH_BIT:
1881 return "VK_IMAGE_ASPECT_DEPTH_BIT";
1882 case VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT:
1883 return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
1884 case VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT:
1885 return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
1886 case VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT:
1887 return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
1888 case VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT:
1889 return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
1890 case VK_IMAGE_ASPECT_METADATA_BIT:
1891 return "VK_IMAGE_ASPECT_METADATA_BIT";
1892 case VK_IMAGE_ASPECT_PLANE_0_BIT:
1893 return "VK_IMAGE_ASPECT_PLANE_0_BIT";
1894 case VK_IMAGE_ASPECT_PLANE_1_BIT:
1895 return "VK_IMAGE_ASPECT_PLANE_1_BIT";
1896 case VK_IMAGE_ASPECT_PLANE_2_BIT:
1897 return "VK_IMAGE_ASPECT_PLANE_2_BIT";
1898 case VK_IMAGE_ASPECT_STENCIL_BIT:
1899 return "VK_IMAGE_ASPECT_STENCIL_BIT";
1900 default:
1901 return "Unhandled VkImageAspectFlagBits";
1902 }
1903 }
1904
string_VkImageAspectFlags(VkImageAspectFlags input_value)1905 static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value)
1906 {
1907 std::string ret;
1908 int index = 0;
1909 while(input_value) {
1910 if (input_value & 1) {
1911 if( !ret.empty()) ret.append("|");
1912 ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(1 << index)));
1913 }
1914 ++index;
1915 input_value >>= 1;
1916 }
1917 if( ret.empty()) ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(0)));
1918 return ret;
1919 }
1920
string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)1921 static inline const char* string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)
1922 {
1923 switch ((VkSparseImageFormatFlagBits)input_value)
1924 {
1925 case VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT:
1926 return "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT";
1927 case VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT:
1928 return "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT";
1929 case VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT:
1930 return "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT";
1931 default:
1932 return "Unhandled VkSparseImageFormatFlagBits";
1933 }
1934 }
1935
string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value)1936 static inline std::string string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value)
1937 {
1938 std::string ret;
1939 int index = 0;
1940 while(input_value) {
1941 if (input_value & 1) {
1942 if( !ret.empty()) ret.append("|");
1943 ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(1 << index)));
1944 }
1945 ++index;
1946 input_value >>= 1;
1947 }
1948 if( ret.empty()) ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(0)));
1949 return ret;
1950 }
1951
string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)1952 static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)
1953 {
1954 switch ((VkSparseMemoryBindFlagBits)input_value)
1955 {
1956 case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
1957 return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
1958 default:
1959 return "Unhandled VkSparseMemoryBindFlagBits";
1960 }
1961 }
1962
string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value)1963 static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value)
1964 {
1965 std::string ret;
1966 int index = 0;
1967 while(input_value) {
1968 if (input_value & 1) {
1969 if( !ret.empty()) ret.append("|");
1970 ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(1 << index)));
1971 }
1972 ++index;
1973 input_value >>= 1;
1974 }
1975 if( ret.empty()) ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(0)));
1976 return ret;
1977 }
1978
string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)1979 static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)
1980 {
1981 switch ((VkFenceCreateFlagBits)input_value)
1982 {
1983 case VK_FENCE_CREATE_SIGNALED_BIT:
1984 return "VK_FENCE_CREATE_SIGNALED_BIT";
1985 default:
1986 return "Unhandled VkFenceCreateFlagBits";
1987 }
1988 }
1989
string_VkFenceCreateFlags(VkFenceCreateFlags input_value)1990 static inline std::string string_VkFenceCreateFlags(VkFenceCreateFlags input_value)
1991 {
1992 std::string ret;
1993 int index = 0;
1994 while(input_value) {
1995 if (input_value & 1) {
1996 if( !ret.empty()) ret.append("|");
1997 ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(1 << index)));
1998 }
1999 ++index;
2000 input_value >>= 1;
2001 }
2002 if( ret.empty()) ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(0)));
2003 return ret;
2004 }
2005
string_VkQueryType(VkQueryType input_value)2006 static inline const char* string_VkQueryType(VkQueryType input_value)
2007 {
2008 switch ((VkQueryType)input_value)
2009 {
2010 case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV:
2011 return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV";
2012 case VK_QUERY_TYPE_OCCLUSION:
2013 return "VK_QUERY_TYPE_OCCLUSION";
2014 case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL:
2015 return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL";
2016 case VK_QUERY_TYPE_PIPELINE_STATISTICS:
2017 return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
2018 case VK_QUERY_TYPE_TIMESTAMP:
2019 return "VK_QUERY_TYPE_TIMESTAMP";
2020 case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT:
2021 return "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT";
2022 default:
2023 return "Unhandled VkQueryType";
2024 }
2025 }
2026
string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)2027 static inline const char* string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)
2028 {
2029 switch ((VkQueryPipelineStatisticFlagBits)input_value)
2030 {
2031 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT:
2032 return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT";
2033 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT:
2034 return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT";
2035 case VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT:
2036 return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT";
2037 case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
2038 return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT";
2039 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT:
2040 return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT";
2041 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT:
2042 return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT";
2043 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
2044 return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT";
2045 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
2046 return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT";
2047 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT:
2048 return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT";
2049 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT:
2050 return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT";
2051 case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
2052 return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT";
2053 default:
2054 return "Unhandled VkQueryPipelineStatisticFlagBits";
2055 }
2056 }
2057
string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags input_value)2058 static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags input_value)
2059 {
2060 std::string ret;
2061 int index = 0;
2062 while(input_value) {
2063 if (input_value & 1) {
2064 if( !ret.empty()) ret.append("|");
2065 ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(1 << index)));
2066 }
2067 ++index;
2068 input_value >>= 1;
2069 }
2070 if( ret.empty()) ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(0)));
2071 return ret;
2072 }
2073
string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)2074 static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)
2075 {
2076 switch ((VkQueryResultFlagBits)input_value)
2077 {
2078 case VK_QUERY_RESULT_64_BIT:
2079 return "VK_QUERY_RESULT_64_BIT";
2080 case VK_QUERY_RESULT_PARTIAL_BIT:
2081 return "VK_QUERY_RESULT_PARTIAL_BIT";
2082 case VK_QUERY_RESULT_WAIT_BIT:
2083 return "VK_QUERY_RESULT_WAIT_BIT";
2084 case VK_QUERY_RESULT_WITH_AVAILABILITY_BIT:
2085 return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT";
2086 default:
2087 return "Unhandled VkQueryResultFlagBits";
2088 }
2089 }
2090
string_VkQueryResultFlags(VkQueryResultFlags input_value)2091 static inline std::string string_VkQueryResultFlags(VkQueryResultFlags input_value)
2092 {
2093 std::string ret;
2094 int index = 0;
2095 while(input_value) {
2096 if (input_value & 1) {
2097 if( !ret.empty()) ret.append("|");
2098 ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(1 << index)));
2099 }
2100 ++index;
2101 input_value >>= 1;
2102 }
2103 if( ret.empty()) ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(0)));
2104 return ret;
2105 }
2106
string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)2107 static inline const char* string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)
2108 {
2109 switch ((VkBufferCreateFlagBits)input_value)
2110 {
2111 case VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT:
2112 return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT";
2113 case VK_BUFFER_CREATE_PROTECTED_BIT:
2114 return "VK_BUFFER_CREATE_PROTECTED_BIT";
2115 case VK_BUFFER_CREATE_SPARSE_ALIASED_BIT:
2116 return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT";
2117 case VK_BUFFER_CREATE_SPARSE_BINDING_BIT:
2118 return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT";
2119 case VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT:
2120 return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT";
2121 default:
2122 return "Unhandled VkBufferCreateFlagBits";
2123 }
2124 }
2125
string_VkBufferCreateFlags(VkBufferCreateFlags input_value)2126 static inline std::string string_VkBufferCreateFlags(VkBufferCreateFlags input_value)
2127 {
2128 std::string ret;
2129 int index = 0;
2130 while(input_value) {
2131 if (input_value & 1) {
2132 if( !ret.empty()) ret.append("|");
2133 ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(1 << index)));
2134 }
2135 ++index;
2136 input_value >>= 1;
2137 }
2138 if( ret.empty()) ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(0)));
2139 return ret;
2140 }
2141
string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)2142 static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)
2143 {
2144 switch ((VkBufferUsageFlagBits)input_value)
2145 {
2146 case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT:
2147 return "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT";
2148 case VK_BUFFER_USAGE_INDEX_BUFFER_BIT:
2149 return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
2150 case VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT:
2151 return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
2152 case VK_BUFFER_USAGE_RAY_TRACING_BIT_NV:
2153 return "VK_BUFFER_USAGE_RAY_TRACING_BIT_NV";
2154 case VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT:
2155 return "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT";
2156 case VK_BUFFER_USAGE_STORAGE_BUFFER_BIT:
2157 return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT";
2158 case VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT:
2159 return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT";
2160 case VK_BUFFER_USAGE_TRANSFER_DST_BIT:
2161 return "VK_BUFFER_USAGE_TRANSFER_DST_BIT";
2162 case VK_BUFFER_USAGE_TRANSFER_SRC_BIT:
2163 return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT";
2164 case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT:
2165 return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
2166 case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT:
2167 return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
2168 case VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT:
2169 return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT";
2170 case VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT:
2171 return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT";
2172 case VK_BUFFER_USAGE_VERTEX_BUFFER_BIT:
2173 return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
2174 default:
2175 return "Unhandled VkBufferUsageFlagBits";
2176 }
2177 }
2178
string_VkBufferUsageFlags(VkBufferUsageFlags input_value)2179 static inline std::string string_VkBufferUsageFlags(VkBufferUsageFlags input_value)
2180 {
2181 std::string ret;
2182 int index = 0;
2183 while(input_value) {
2184 if (input_value & 1) {
2185 if( !ret.empty()) ret.append("|");
2186 ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(1 << index)));
2187 }
2188 ++index;
2189 input_value >>= 1;
2190 }
2191 if( ret.empty()) ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(0)));
2192 return ret;
2193 }
2194
string_VkSharingMode(VkSharingMode input_value)2195 static inline const char* string_VkSharingMode(VkSharingMode input_value)
2196 {
2197 switch ((VkSharingMode)input_value)
2198 {
2199 case VK_SHARING_MODE_CONCURRENT:
2200 return "VK_SHARING_MODE_CONCURRENT";
2201 case VK_SHARING_MODE_EXCLUSIVE:
2202 return "VK_SHARING_MODE_EXCLUSIVE";
2203 default:
2204 return "Unhandled VkSharingMode";
2205 }
2206 }
2207
string_VkImageLayout(VkImageLayout input_value)2208 static inline const char* string_VkImageLayout(VkImageLayout input_value)
2209 {
2210 switch ((VkImageLayout)input_value)
2211 {
2212 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
2213 return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
2214 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
2215 return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
2216 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
2217 return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
2218 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
2219 return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
2220 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
2221 return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
2222 case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
2223 return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
2224 case VK_IMAGE_LAYOUT_GENERAL:
2225 return "VK_IMAGE_LAYOUT_GENERAL";
2226 case VK_IMAGE_LAYOUT_PREINITIALIZED:
2227 return "VK_IMAGE_LAYOUT_PREINITIALIZED";
2228 case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
2229 return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
2230 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
2231 return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
2232 case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV:
2233 return "VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV";
2234 case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
2235 return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
2236 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
2237 return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
2238 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
2239 return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
2240 case VK_IMAGE_LAYOUT_UNDEFINED:
2241 return "VK_IMAGE_LAYOUT_UNDEFINED";
2242 default:
2243 return "Unhandled VkImageLayout";
2244 }
2245 }
2246
string_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits input_value)2247 static inline const char* string_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits input_value)
2248 {
2249 switch ((VkImageViewCreateFlagBits)input_value)
2250 {
2251 case VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT:
2252 return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT";
2253 default:
2254 return "Unhandled VkImageViewCreateFlagBits";
2255 }
2256 }
2257
string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value)2258 static inline std::string string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value)
2259 {
2260 std::string ret;
2261 int index = 0;
2262 while(input_value) {
2263 if (input_value & 1) {
2264 if( !ret.empty()) ret.append("|");
2265 ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(1 << index)));
2266 }
2267 ++index;
2268 input_value >>= 1;
2269 }
2270 if( ret.empty()) ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(0)));
2271 return ret;
2272 }
2273
string_VkImageViewType(VkImageViewType input_value)2274 static inline const char* string_VkImageViewType(VkImageViewType input_value)
2275 {
2276 switch ((VkImageViewType)input_value)
2277 {
2278 case VK_IMAGE_VIEW_TYPE_1D:
2279 return "VK_IMAGE_VIEW_TYPE_1D";
2280 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
2281 return "VK_IMAGE_VIEW_TYPE_1D_ARRAY";
2282 case VK_IMAGE_VIEW_TYPE_2D:
2283 return "VK_IMAGE_VIEW_TYPE_2D";
2284 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
2285 return "VK_IMAGE_VIEW_TYPE_2D_ARRAY";
2286 case VK_IMAGE_VIEW_TYPE_3D:
2287 return "VK_IMAGE_VIEW_TYPE_3D";
2288 case VK_IMAGE_VIEW_TYPE_CUBE:
2289 return "VK_IMAGE_VIEW_TYPE_CUBE";
2290 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
2291 return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY";
2292 default:
2293 return "Unhandled VkImageViewType";
2294 }
2295 }
2296
string_VkComponentSwizzle(VkComponentSwizzle input_value)2297 static inline const char* string_VkComponentSwizzle(VkComponentSwizzle input_value)
2298 {
2299 switch ((VkComponentSwizzle)input_value)
2300 {
2301 case VK_COMPONENT_SWIZZLE_A:
2302 return "VK_COMPONENT_SWIZZLE_A";
2303 case VK_COMPONENT_SWIZZLE_B:
2304 return "VK_COMPONENT_SWIZZLE_B";
2305 case VK_COMPONENT_SWIZZLE_G:
2306 return "VK_COMPONENT_SWIZZLE_G";
2307 case VK_COMPONENT_SWIZZLE_IDENTITY:
2308 return "VK_COMPONENT_SWIZZLE_IDENTITY";
2309 case VK_COMPONENT_SWIZZLE_ONE:
2310 return "VK_COMPONENT_SWIZZLE_ONE";
2311 case VK_COMPONENT_SWIZZLE_R:
2312 return "VK_COMPONENT_SWIZZLE_R";
2313 case VK_COMPONENT_SWIZZLE_ZERO:
2314 return "VK_COMPONENT_SWIZZLE_ZERO";
2315 default:
2316 return "Unhandled VkComponentSwizzle";
2317 }
2318 }
2319
string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)2320 static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)
2321 {
2322 switch ((VkPipelineCreateFlagBits)input_value)
2323 {
2324 case VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT:
2325 return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
2326 case VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR:
2327 return "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
2328 case VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR:
2329 return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
2330 case VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV:
2331 return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
2332 case VK_PIPELINE_CREATE_DERIVATIVE_BIT:
2333 return "VK_PIPELINE_CREATE_DERIVATIVE_BIT";
2334 case VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
2335 return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
2336 case VK_PIPELINE_CREATE_DISPATCH_BASE:
2337 return "VK_PIPELINE_CREATE_DISPATCH_BASE";
2338 case VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT:
2339 return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
2340 default:
2341 return "Unhandled VkPipelineCreateFlagBits";
2342 }
2343 }
2344
string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value)2345 static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value)
2346 {
2347 std::string ret;
2348 int index = 0;
2349 while(input_value) {
2350 if (input_value & 1) {
2351 if( !ret.empty()) ret.append("|");
2352 ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(1 << index)));
2353 }
2354 ++index;
2355 input_value >>= 1;
2356 }
2357 if( ret.empty()) ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(0)));
2358 return ret;
2359 }
2360
string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)2361 static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)
2362 {
2363 switch ((VkPipelineShaderStageCreateFlagBits)input_value)
2364 {
2365 case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT:
2366 return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT";
2367 case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT:
2368 return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT";
2369 default:
2370 return "Unhandled VkPipelineShaderStageCreateFlagBits";
2371 }
2372 }
2373
string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)2374 static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)
2375 {
2376 std::string ret;
2377 int index = 0;
2378 while(input_value) {
2379 if (input_value & 1) {
2380 if( !ret.empty()) ret.append("|");
2381 ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1 << index)));
2382 }
2383 ++index;
2384 input_value >>= 1;
2385 }
2386 if( ret.empty()) ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(0)));
2387 return ret;
2388 }
2389
string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)2390 static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)
2391 {
2392 switch ((VkShaderStageFlagBits)input_value)
2393 {
2394 case VK_SHADER_STAGE_ALL:
2395 return "VK_SHADER_STAGE_ALL";
2396 case VK_SHADER_STAGE_ALL_GRAPHICS:
2397 return "VK_SHADER_STAGE_ALL_GRAPHICS";
2398 case VK_SHADER_STAGE_ANY_HIT_BIT_NV:
2399 return "VK_SHADER_STAGE_ANY_HIT_BIT_NV";
2400 case VK_SHADER_STAGE_CALLABLE_BIT_NV:
2401 return "VK_SHADER_STAGE_CALLABLE_BIT_NV";
2402 case VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV:
2403 return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV";
2404 case VK_SHADER_STAGE_COMPUTE_BIT:
2405 return "VK_SHADER_STAGE_COMPUTE_BIT";
2406 case VK_SHADER_STAGE_FRAGMENT_BIT:
2407 return "VK_SHADER_STAGE_FRAGMENT_BIT";
2408 case VK_SHADER_STAGE_GEOMETRY_BIT:
2409 return "VK_SHADER_STAGE_GEOMETRY_BIT";
2410 case VK_SHADER_STAGE_INTERSECTION_BIT_NV:
2411 return "VK_SHADER_STAGE_INTERSECTION_BIT_NV";
2412 case VK_SHADER_STAGE_MESH_BIT_NV:
2413 return "VK_SHADER_STAGE_MESH_BIT_NV";
2414 case VK_SHADER_STAGE_MISS_BIT_NV:
2415 return "VK_SHADER_STAGE_MISS_BIT_NV";
2416 case VK_SHADER_STAGE_RAYGEN_BIT_NV:
2417 return "VK_SHADER_STAGE_RAYGEN_BIT_NV";
2418 case VK_SHADER_STAGE_TASK_BIT_NV:
2419 return "VK_SHADER_STAGE_TASK_BIT_NV";
2420 case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
2421 return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
2422 case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
2423 return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
2424 case VK_SHADER_STAGE_VERTEX_BIT:
2425 return "VK_SHADER_STAGE_VERTEX_BIT";
2426 default:
2427 return "Unhandled VkShaderStageFlagBits";
2428 }
2429 }
2430
string_VkShaderStageFlags(VkShaderStageFlags input_value)2431 static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_value)
2432 {
2433 std::string ret;
2434 int index = 0;
2435 while(input_value) {
2436 if (input_value & 1) {
2437 if( !ret.empty()) ret.append("|");
2438 ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(1 << index)));
2439 }
2440 ++index;
2441 input_value >>= 1;
2442 }
2443 if( ret.empty()) ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(0)));
2444 return ret;
2445 }
2446
string_VkVertexInputRate(VkVertexInputRate input_value)2447 static inline const char* string_VkVertexInputRate(VkVertexInputRate input_value)
2448 {
2449 switch ((VkVertexInputRate)input_value)
2450 {
2451 case VK_VERTEX_INPUT_RATE_INSTANCE:
2452 return "VK_VERTEX_INPUT_RATE_INSTANCE";
2453 case VK_VERTEX_INPUT_RATE_VERTEX:
2454 return "VK_VERTEX_INPUT_RATE_VERTEX";
2455 default:
2456 return "Unhandled VkVertexInputRate";
2457 }
2458 }
2459
string_VkPrimitiveTopology(VkPrimitiveTopology input_value)2460 static inline const char* string_VkPrimitiveTopology(VkPrimitiveTopology input_value)
2461 {
2462 switch ((VkPrimitiveTopology)input_value)
2463 {
2464 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
2465 return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST";
2466 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
2467 return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY";
2468 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
2469 return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP";
2470 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
2471 return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY";
2472 case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
2473 return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST";
2474 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
2475 return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST";
2476 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
2477 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN";
2478 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
2479 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST";
2480 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
2481 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY";
2482 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
2483 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP";
2484 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
2485 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY";
2486 default:
2487 return "Unhandled VkPrimitiveTopology";
2488 }
2489 }
2490
string_VkPolygonMode(VkPolygonMode input_value)2491 static inline const char* string_VkPolygonMode(VkPolygonMode input_value)
2492 {
2493 switch ((VkPolygonMode)input_value)
2494 {
2495 case VK_POLYGON_MODE_FILL:
2496 return "VK_POLYGON_MODE_FILL";
2497 case VK_POLYGON_MODE_FILL_RECTANGLE_NV:
2498 return "VK_POLYGON_MODE_FILL_RECTANGLE_NV";
2499 case VK_POLYGON_MODE_LINE:
2500 return "VK_POLYGON_MODE_LINE";
2501 case VK_POLYGON_MODE_POINT:
2502 return "VK_POLYGON_MODE_POINT";
2503 default:
2504 return "Unhandled VkPolygonMode";
2505 }
2506 }
2507
string_VkCullModeFlagBits(VkCullModeFlagBits input_value)2508 static inline const char* string_VkCullModeFlagBits(VkCullModeFlagBits input_value)
2509 {
2510 switch ((VkCullModeFlagBits)input_value)
2511 {
2512 case VK_CULL_MODE_BACK_BIT:
2513 return "VK_CULL_MODE_BACK_BIT";
2514 case VK_CULL_MODE_FRONT_AND_BACK:
2515 return "VK_CULL_MODE_FRONT_AND_BACK";
2516 case VK_CULL_MODE_FRONT_BIT:
2517 return "VK_CULL_MODE_FRONT_BIT";
2518 case VK_CULL_MODE_NONE:
2519 return "VK_CULL_MODE_NONE";
2520 default:
2521 return "Unhandled VkCullModeFlagBits";
2522 }
2523 }
2524
string_VkCullModeFlags(VkCullModeFlags input_value)2525 static inline std::string string_VkCullModeFlags(VkCullModeFlags input_value)
2526 {
2527 std::string ret;
2528 int index = 0;
2529 while(input_value) {
2530 if (input_value & 1) {
2531 if( !ret.empty()) ret.append("|");
2532 ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(1 << index)));
2533 }
2534 ++index;
2535 input_value >>= 1;
2536 }
2537 if( ret.empty()) ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(0)));
2538 return ret;
2539 }
2540
string_VkFrontFace(VkFrontFace input_value)2541 static inline const char* string_VkFrontFace(VkFrontFace input_value)
2542 {
2543 switch ((VkFrontFace)input_value)
2544 {
2545 case VK_FRONT_FACE_CLOCKWISE:
2546 return "VK_FRONT_FACE_CLOCKWISE";
2547 case VK_FRONT_FACE_COUNTER_CLOCKWISE:
2548 return "VK_FRONT_FACE_COUNTER_CLOCKWISE";
2549 default:
2550 return "Unhandled VkFrontFace";
2551 }
2552 }
2553
string_VkCompareOp(VkCompareOp input_value)2554 static inline const char* string_VkCompareOp(VkCompareOp input_value)
2555 {
2556 switch ((VkCompareOp)input_value)
2557 {
2558 case VK_COMPARE_OP_ALWAYS:
2559 return "VK_COMPARE_OP_ALWAYS";
2560 case VK_COMPARE_OP_EQUAL:
2561 return "VK_COMPARE_OP_EQUAL";
2562 case VK_COMPARE_OP_GREATER:
2563 return "VK_COMPARE_OP_GREATER";
2564 case VK_COMPARE_OP_GREATER_OR_EQUAL:
2565 return "VK_COMPARE_OP_GREATER_OR_EQUAL";
2566 case VK_COMPARE_OP_LESS:
2567 return "VK_COMPARE_OP_LESS";
2568 case VK_COMPARE_OP_LESS_OR_EQUAL:
2569 return "VK_COMPARE_OP_LESS_OR_EQUAL";
2570 case VK_COMPARE_OP_NEVER:
2571 return "VK_COMPARE_OP_NEVER";
2572 case VK_COMPARE_OP_NOT_EQUAL:
2573 return "VK_COMPARE_OP_NOT_EQUAL";
2574 default:
2575 return "Unhandled VkCompareOp";
2576 }
2577 }
2578
string_VkStencilOp(VkStencilOp input_value)2579 static inline const char* string_VkStencilOp(VkStencilOp input_value)
2580 {
2581 switch ((VkStencilOp)input_value)
2582 {
2583 case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
2584 return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
2585 case VK_STENCIL_OP_DECREMENT_AND_WRAP:
2586 return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
2587 case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
2588 return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
2589 case VK_STENCIL_OP_INCREMENT_AND_WRAP:
2590 return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
2591 case VK_STENCIL_OP_INVERT:
2592 return "VK_STENCIL_OP_INVERT";
2593 case VK_STENCIL_OP_KEEP:
2594 return "VK_STENCIL_OP_KEEP";
2595 case VK_STENCIL_OP_REPLACE:
2596 return "VK_STENCIL_OP_REPLACE";
2597 case VK_STENCIL_OP_ZERO:
2598 return "VK_STENCIL_OP_ZERO";
2599 default:
2600 return "Unhandled VkStencilOp";
2601 }
2602 }
2603
string_VkLogicOp(VkLogicOp input_value)2604 static inline const char* string_VkLogicOp(VkLogicOp input_value)
2605 {
2606 switch ((VkLogicOp)input_value)
2607 {
2608 case VK_LOGIC_OP_AND:
2609 return "VK_LOGIC_OP_AND";
2610 case VK_LOGIC_OP_AND_INVERTED:
2611 return "VK_LOGIC_OP_AND_INVERTED";
2612 case VK_LOGIC_OP_AND_REVERSE:
2613 return "VK_LOGIC_OP_AND_REVERSE";
2614 case VK_LOGIC_OP_CLEAR:
2615 return "VK_LOGIC_OP_CLEAR";
2616 case VK_LOGIC_OP_COPY:
2617 return "VK_LOGIC_OP_COPY";
2618 case VK_LOGIC_OP_COPY_INVERTED:
2619 return "VK_LOGIC_OP_COPY_INVERTED";
2620 case VK_LOGIC_OP_EQUIVALENT:
2621 return "VK_LOGIC_OP_EQUIVALENT";
2622 case VK_LOGIC_OP_INVERT:
2623 return "VK_LOGIC_OP_INVERT";
2624 case VK_LOGIC_OP_NAND:
2625 return "VK_LOGIC_OP_NAND";
2626 case VK_LOGIC_OP_NOR:
2627 return "VK_LOGIC_OP_NOR";
2628 case VK_LOGIC_OP_NO_OP:
2629 return "VK_LOGIC_OP_NO_OP";
2630 case VK_LOGIC_OP_OR:
2631 return "VK_LOGIC_OP_OR";
2632 case VK_LOGIC_OP_OR_INVERTED:
2633 return "VK_LOGIC_OP_OR_INVERTED";
2634 case VK_LOGIC_OP_OR_REVERSE:
2635 return "VK_LOGIC_OP_OR_REVERSE";
2636 case VK_LOGIC_OP_SET:
2637 return "VK_LOGIC_OP_SET";
2638 case VK_LOGIC_OP_XOR:
2639 return "VK_LOGIC_OP_XOR";
2640 default:
2641 return "Unhandled VkLogicOp";
2642 }
2643 }
2644
string_VkBlendFactor(VkBlendFactor input_value)2645 static inline const char* string_VkBlendFactor(VkBlendFactor input_value)
2646 {
2647 switch ((VkBlendFactor)input_value)
2648 {
2649 case VK_BLEND_FACTOR_CONSTANT_ALPHA:
2650 return "VK_BLEND_FACTOR_CONSTANT_ALPHA";
2651 case VK_BLEND_FACTOR_CONSTANT_COLOR:
2652 return "VK_BLEND_FACTOR_CONSTANT_COLOR";
2653 case VK_BLEND_FACTOR_DST_ALPHA:
2654 return "VK_BLEND_FACTOR_DST_ALPHA";
2655 case VK_BLEND_FACTOR_DST_COLOR:
2656 return "VK_BLEND_FACTOR_DST_COLOR";
2657 case VK_BLEND_FACTOR_ONE:
2658 return "VK_BLEND_FACTOR_ONE";
2659 case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
2660 return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA";
2661 case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
2662 return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR";
2663 case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
2664 return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA";
2665 case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
2666 return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR";
2667 case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
2668 return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA";
2669 case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
2670 return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR";
2671 case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
2672 return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA";
2673 case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
2674 return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR";
2675 case VK_BLEND_FACTOR_SRC1_ALPHA:
2676 return "VK_BLEND_FACTOR_SRC1_ALPHA";
2677 case VK_BLEND_FACTOR_SRC1_COLOR:
2678 return "VK_BLEND_FACTOR_SRC1_COLOR";
2679 case VK_BLEND_FACTOR_SRC_ALPHA:
2680 return "VK_BLEND_FACTOR_SRC_ALPHA";
2681 case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
2682 return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE";
2683 case VK_BLEND_FACTOR_SRC_COLOR:
2684 return "VK_BLEND_FACTOR_SRC_COLOR";
2685 case VK_BLEND_FACTOR_ZERO:
2686 return "VK_BLEND_FACTOR_ZERO";
2687 default:
2688 return "Unhandled VkBlendFactor";
2689 }
2690 }
2691
string_VkBlendOp(VkBlendOp input_value)2692 static inline const char* string_VkBlendOp(VkBlendOp input_value)
2693 {
2694 switch ((VkBlendOp)input_value)
2695 {
2696 case VK_BLEND_OP_ADD:
2697 return "VK_BLEND_OP_ADD";
2698 case VK_BLEND_OP_BLUE_EXT:
2699 return "VK_BLEND_OP_BLUE_EXT";
2700 case VK_BLEND_OP_COLORBURN_EXT:
2701 return "VK_BLEND_OP_COLORBURN_EXT";
2702 case VK_BLEND_OP_COLORDODGE_EXT:
2703 return "VK_BLEND_OP_COLORDODGE_EXT";
2704 case VK_BLEND_OP_CONTRAST_EXT:
2705 return "VK_BLEND_OP_CONTRAST_EXT";
2706 case VK_BLEND_OP_DARKEN_EXT:
2707 return "VK_BLEND_OP_DARKEN_EXT";
2708 case VK_BLEND_OP_DIFFERENCE_EXT:
2709 return "VK_BLEND_OP_DIFFERENCE_EXT";
2710 case VK_BLEND_OP_DST_ATOP_EXT:
2711 return "VK_BLEND_OP_DST_ATOP_EXT";
2712 case VK_BLEND_OP_DST_EXT:
2713 return "VK_BLEND_OP_DST_EXT";
2714 case VK_BLEND_OP_DST_IN_EXT:
2715 return "VK_BLEND_OP_DST_IN_EXT";
2716 case VK_BLEND_OP_DST_OUT_EXT:
2717 return "VK_BLEND_OP_DST_OUT_EXT";
2718 case VK_BLEND_OP_DST_OVER_EXT:
2719 return "VK_BLEND_OP_DST_OVER_EXT";
2720 case VK_BLEND_OP_EXCLUSION_EXT:
2721 return "VK_BLEND_OP_EXCLUSION_EXT";
2722 case VK_BLEND_OP_GREEN_EXT:
2723 return "VK_BLEND_OP_GREEN_EXT";
2724 case VK_BLEND_OP_HARDLIGHT_EXT:
2725 return "VK_BLEND_OP_HARDLIGHT_EXT";
2726 case VK_BLEND_OP_HARDMIX_EXT:
2727 return "VK_BLEND_OP_HARDMIX_EXT";
2728 case VK_BLEND_OP_HSL_COLOR_EXT:
2729 return "VK_BLEND_OP_HSL_COLOR_EXT";
2730 case VK_BLEND_OP_HSL_HUE_EXT:
2731 return "VK_BLEND_OP_HSL_HUE_EXT";
2732 case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
2733 return "VK_BLEND_OP_HSL_LUMINOSITY_EXT";
2734 case VK_BLEND_OP_HSL_SATURATION_EXT:
2735 return "VK_BLEND_OP_HSL_SATURATION_EXT";
2736 case VK_BLEND_OP_INVERT_EXT:
2737 return "VK_BLEND_OP_INVERT_EXT";
2738 case VK_BLEND_OP_INVERT_OVG_EXT:
2739 return "VK_BLEND_OP_INVERT_OVG_EXT";
2740 case VK_BLEND_OP_INVERT_RGB_EXT:
2741 return "VK_BLEND_OP_INVERT_RGB_EXT";
2742 case VK_BLEND_OP_LIGHTEN_EXT:
2743 return "VK_BLEND_OP_LIGHTEN_EXT";
2744 case VK_BLEND_OP_LINEARBURN_EXT:
2745 return "VK_BLEND_OP_LINEARBURN_EXT";
2746 case VK_BLEND_OP_LINEARDODGE_EXT:
2747 return "VK_BLEND_OP_LINEARDODGE_EXT";
2748 case VK_BLEND_OP_LINEARLIGHT_EXT:
2749 return "VK_BLEND_OP_LINEARLIGHT_EXT";
2750 case VK_BLEND_OP_MAX:
2751 return "VK_BLEND_OP_MAX";
2752 case VK_BLEND_OP_MIN:
2753 return "VK_BLEND_OP_MIN";
2754 case VK_BLEND_OP_MINUS_CLAMPED_EXT:
2755 return "VK_BLEND_OP_MINUS_CLAMPED_EXT";
2756 case VK_BLEND_OP_MINUS_EXT:
2757 return "VK_BLEND_OP_MINUS_EXT";
2758 case VK_BLEND_OP_MULTIPLY_EXT:
2759 return "VK_BLEND_OP_MULTIPLY_EXT";
2760 case VK_BLEND_OP_OVERLAY_EXT:
2761 return "VK_BLEND_OP_OVERLAY_EXT";
2762 case VK_BLEND_OP_PINLIGHT_EXT:
2763 return "VK_BLEND_OP_PINLIGHT_EXT";
2764 case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT:
2765 return "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT";
2766 case VK_BLEND_OP_PLUS_CLAMPED_EXT:
2767 return "VK_BLEND_OP_PLUS_CLAMPED_EXT";
2768 case VK_BLEND_OP_PLUS_DARKER_EXT:
2769 return "VK_BLEND_OP_PLUS_DARKER_EXT";
2770 case VK_BLEND_OP_PLUS_EXT:
2771 return "VK_BLEND_OP_PLUS_EXT";
2772 case VK_BLEND_OP_RED_EXT:
2773 return "VK_BLEND_OP_RED_EXT";
2774 case VK_BLEND_OP_REVERSE_SUBTRACT:
2775 return "VK_BLEND_OP_REVERSE_SUBTRACT";
2776 case VK_BLEND_OP_SCREEN_EXT:
2777 return "VK_BLEND_OP_SCREEN_EXT";
2778 case VK_BLEND_OP_SOFTLIGHT_EXT:
2779 return "VK_BLEND_OP_SOFTLIGHT_EXT";
2780 case VK_BLEND_OP_SRC_ATOP_EXT:
2781 return "VK_BLEND_OP_SRC_ATOP_EXT";
2782 case VK_BLEND_OP_SRC_EXT:
2783 return "VK_BLEND_OP_SRC_EXT";
2784 case VK_BLEND_OP_SRC_IN_EXT:
2785 return "VK_BLEND_OP_SRC_IN_EXT";
2786 case VK_BLEND_OP_SRC_OUT_EXT:
2787 return "VK_BLEND_OP_SRC_OUT_EXT";
2788 case VK_BLEND_OP_SRC_OVER_EXT:
2789 return "VK_BLEND_OP_SRC_OVER_EXT";
2790 case VK_BLEND_OP_SUBTRACT:
2791 return "VK_BLEND_OP_SUBTRACT";
2792 case VK_BLEND_OP_VIVIDLIGHT_EXT:
2793 return "VK_BLEND_OP_VIVIDLIGHT_EXT";
2794 case VK_BLEND_OP_XOR_EXT:
2795 return "VK_BLEND_OP_XOR_EXT";
2796 case VK_BLEND_OP_ZERO_EXT:
2797 return "VK_BLEND_OP_ZERO_EXT";
2798 default:
2799 return "Unhandled VkBlendOp";
2800 }
2801 }
2802
string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)2803 static inline const char* string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)
2804 {
2805 switch ((VkColorComponentFlagBits)input_value)
2806 {
2807 case VK_COLOR_COMPONENT_A_BIT:
2808 return "VK_COLOR_COMPONENT_A_BIT";
2809 case VK_COLOR_COMPONENT_B_BIT:
2810 return "VK_COLOR_COMPONENT_B_BIT";
2811 case VK_COLOR_COMPONENT_G_BIT:
2812 return "VK_COLOR_COMPONENT_G_BIT";
2813 case VK_COLOR_COMPONENT_R_BIT:
2814 return "VK_COLOR_COMPONENT_R_BIT";
2815 default:
2816 return "Unhandled VkColorComponentFlagBits";
2817 }
2818 }
2819
string_VkColorComponentFlags(VkColorComponentFlags input_value)2820 static inline std::string string_VkColorComponentFlags(VkColorComponentFlags input_value)
2821 {
2822 std::string ret;
2823 int index = 0;
2824 while(input_value) {
2825 if (input_value & 1) {
2826 if( !ret.empty()) ret.append("|");
2827 ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(1 << index)));
2828 }
2829 ++index;
2830 input_value >>= 1;
2831 }
2832 if( ret.empty()) ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(0)));
2833 return ret;
2834 }
2835
string_VkDynamicState(VkDynamicState input_value)2836 static inline const char* string_VkDynamicState(VkDynamicState input_value)
2837 {
2838 switch ((VkDynamicState)input_value)
2839 {
2840 case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
2841 return "VK_DYNAMIC_STATE_BLEND_CONSTANTS";
2842 case VK_DYNAMIC_STATE_DEPTH_BIAS:
2843 return "VK_DYNAMIC_STATE_DEPTH_BIAS";
2844 case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
2845 return "VK_DYNAMIC_STATE_DEPTH_BOUNDS";
2846 case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
2847 return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT";
2848 case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
2849 return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
2850 case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
2851 return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
2852 case VK_DYNAMIC_STATE_LINE_WIDTH:
2853 return "VK_DYNAMIC_STATE_LINE_WIDTH";
2854 case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
2855 return "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT";
2856 case VK_DYNAMIC_STATE_SCISSOR:
2857 return "VK_DYNAMIC_STATE_SCISSOR";
2858 case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
2859 return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK";
2860 case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
2861 return "VK_DYNAMIC_STATE_STENCIL_REFERENCE";
2862 case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
2863 return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK";
2864 case VK_DYNAMIC_STATE_VIEWPORT:
2865 return "VK_DYNAMIC_STATE_VIEWPORT";
2866 case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
2867 return "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV";
2868 case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
2869 return "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV";
2870 case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
2871 return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV";
2872 default:
2873 return "Unhandled VkDynamicState";
2874 }
2875 }
2876
string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits input_value)2877 static inline const char* string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits input_value)
2878 {
2879 switch ((VkSamplerCreateFlagBits)input_value)
2880 {
2881 case VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT:
2882 return "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT";
2883 case VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT:
2884 return "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT";
2885 default:
2886 return "Unhandled VkSamplerCreateFlagBits";
2887 }
2888 }
2889
string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value)2890 static inline std::string string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value)
2891 {
2892 std::string ret;
2893 int index = 0;
2894 while(input_value) {
2895 if (input_value & 1) {
2896 if( !ret.empty()) ret.append("|");
2897 ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(1 << index)));
2898 }
2899 ++index;
2900 input_value >>= 1;
2901 }
2902 if( ret.empty()) ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(0)));
2903 return ret;
2904 }
2905
string_VkFilter(VkFilter input_value)2906 static inline const char* string_VkFilter(VkFilter input_value)
2907 {
2908 switch ((VkFilter)input_value)
2909 {
2910 case VK_FILTER_CUBIC_IMG:
2911 return "VK_FILTER_CUBIC_IMG";
2912 case VK_FILTER_LINEAR:
2913 return "VK_FILTER_LINEAR";
2914 case VK_FILTER_NEAREST:
2915 return "VK_FILTER_NEAREST";
2916 default:
2917 return "Unhandled VkFilter";
2918 }
2919 }
2920
string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)2921 static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)
2922 {
2923 switch ((VkSamplerMipmapMode)input_value)
2924 {
2925 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
2926 return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
2927 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
2928 return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
2929 default:
2930 return "Unhandled VkSamplerMipmapMode";
2931 }
2932 }
2933
string_VkSamplerAddressMode(VkSamplerAddressMode input_value)2934 static inline const char* string_VkSamplerAddressMode(VkSamplerAddressMode input_value)
2935 {
2936 switch ((VkSamplerAddressMode)input_value)
2937 {
2938 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
2939 return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER";
2940 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
2941 return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE";
2942 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
2943 return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT";
2944 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
2945 return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE";
2946 case VK_SAMPLER_ADDRESS_MODE_REPEAT:
2947 return "VK_SAMPLER_ADDRESS_MODE_REPEAT";
2948 default:
2949 return "Unhandled VkSamplerAddressMode";
2950 }
2951 }
2952
string_VkBorderColor(VkBorderColor input_value)2953 static inline const char* string_VkBorderColor(VkBorderColor input_value)
2954 {
2955 switch ((VkBorderColor)input_value)
2956 {
2957 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
2958 return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK";
2959 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
2960 return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE";
2961 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
2962 return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK";
2963 case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
2964 return "VK_BORDER_COLOR_INT_OPAQUE_BLACK";
2965 case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
2966 return "VK_BORDER_COLOR_INT_OPAQUE_WHITE";
2967 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
2968 return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK";
2969 default:
2970 return "Unhandled VkBorderColor";
2971 }
2972 }
2973
string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)2974 static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)
2975 {
2976 switch ((VkDescriptorSetLayoutCreateFlagBits)input_value)
2977 {
2978 case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR:
2979 return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR";
2980 case VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT:
2981 return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT";
2982 default:
2983 return "Unhandled VkDescriptorSetLayoutCreateFlagBits";
2984 }
2985 }
2986
string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value)2987 static inline std::string string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value)
2988 {
2989 std::string ret;
2990 int index = 0;
2991 while(input_value) {
2992 if (input_value & 1) {
2993 if( !ret.empty()) ret.append("|");
2994 ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(1 << index)));
2995 }
2996 ++index;
2997 input_value >>= 1;
2998 }
2999 if( ret.empty()) ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(0)));
3000 return ret;
3001 }
3002
string_VkDescriptorType(VkDescriptorType input_value)3003 static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
3004 {
3005 switch ((VkDescriptorType)input_value)
3006 {
3007 case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
3008 return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV";
3009 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3010 return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
3011 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
3012 return "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT";
3013 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3014 return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT";
3015 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3016 return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
3017 case VK_DESCRIPTOR_TYPE_SAMPLER:
3018 return "VK_DESCRIPTOR_TYPE_SAMPLER";
3019 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3020 return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
3021 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3022 return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
3023 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3024 return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
3025 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3026 return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
3027 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3028 return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
3029 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3030 return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
3031 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3032 return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
3033 default:
3034 return "Unhandled VkDescriptorType";
3035 }
3036 }
3037
string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)3038 static inline const char* string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)
3039 {
3040 switch ((VkDescriptorPoolCreateFlagBits)input_value)
3041 {
3042 case VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT:
3043 return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT";
3044 case VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT:
3045 return "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT";
3046 default:
3047 return "Unhandled VkDescriptorPoolCreateFlagBits";
3048 }
3049 }
3050
string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value)3051 static inline std::string string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value)
3052 {
3053 std::string ret;
3054 int index = 0;
3055 while(input_value) {
3056 if (input_value & 1) {
3057 if( !ret.empty()) ret.append("|");
3058 ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(1 << index)));
3059 }
3060 ++index;
3061 input_value >>= 1;
3062 }
3063 if( ret.empty()) ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(0)));
3064 return ret;
3065 }
3066
string_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits input_value)3067 static inline const char* string_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits input_value)
3068 {
3069 switch ((VkFramebufferCreateFlagBits)input_value)
3070 {
3071 case VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR:
3072 return "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR";
3073 default:
3074 return "Unhandled VkFramebufferCreateFlagBits";
3075 }
3076 }
3077
string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value)3078 static inline std::string string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value)
3079 {
3080 std::string ret;
3081 int index = 0;
3082 while(input_value) {
3083 if (input_value & 1) {
3084 if( !ret.empty()) ret.append("|");
3085 ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(1 << index)));
3086 }
3087 ++index;
3088 input_value >>= 1;
3089 }
3090 if( ret.empty()) ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(0)));
3091 return ret;
3092 }
3093
string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)3094 static inline const char* string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)
3095 {
3096 switch ((VkAttachmentDescriptionFlagBits)input_value)
3097 {
3098 case VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT:
3099 return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT";
3100 default:
3101 return "Unhandled VkAttachmentDescriptionFlagBits";
3102 }
3103 }
3104
string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value)3105 static inline std::string string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value)
3106 {
3107 std::string ret;
3108 int index = 0;
3109 while(input_value) {
3110 if (input_value & 1) {
3111 if( !ret.empty()) ret.append("|");
3112 ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(1 << index)));
3113 }
3114 ++index;
3115 input_value >>= 1;
3116 }
3117 if( ret.empty()) ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(0)));
3118 return ret;
3119 }
3120
string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)3121 static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)
3122 {
3123 switch ((VkAttachmentLoadOp)input_value)
3124 {
3125 case VK_ATTACHMENT_LOAD_OP_CLEAR:
3126 return "VK_ATTACHMENT_LOAD_OP_CLEAR";
3127 case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
3128 return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
3129 case VK_ATTACHMENT_LOAD_OP_LOAD:
3130 return "VK_ATTACHMENT_LOAD_OP_LOAD";
3131 default:
3132 return "Unhandled VkAttachmentLoadOp";
3133 }
3134 }
3135
string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)3136 static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)
3137 {
3138 switch ((VkAttachmentStoreOp)input_value)
3139 {
3140 case VK_ATTACHMENT_STORE_OP_DONT_CARE:
3141 return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
3142 case VK_ATTACHMENT_STORE_OP_STORE:
3143 return "VK_ATTACHMENT_STORE_OP_STORE";
3144 default:
3145 return "Unhandled VkAttachmentStoreOp";
3146 }
3147 }
3148
string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)3149 static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)
3150 {
3151 switch ((VkSubpassDescriptionFlagBits)input_value)
3152 {
3153 case VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX:
3154 return "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX";
3155 case VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX:
3156 return "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX";
3157 default:
3158 return "Unhandled VkSubpassDescriptionFlagBits";
3159 }
3160 }
3161
string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value)3162 static inline std::string string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value)
3163 {
3164 std::string ret;
3165 int index = 0;
3166 while(input_value) {
3167 if (input_value & 1) {
3168 if( !ret.empty()) ret.append("|");
3169 ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(1 << index)));
3170 }
3171 ++index;
3172 input_value >>= 1;
3173 }
3174 if( ret.empty()) ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(0)));
3175 return ret;
3176 }
3177
string_VkPipelineBindPoint(VkPipelineBindPoint input_value)3178 static inline const char* string_VkPipelineBindPoint(VkPipelineBindPoint input_value)
3179 {
3180 switch ((VkPipelineBindPoint)input_value)
3181 {
3182 case VK_PIPELINE_BIND_POINT_COMPUTE:
3183 return "VK_PIPELINE_BIND_POINT_COMPUTE";
3184 case VK_PIPELINE_BIND_POINT_GRAPHICS:
3185 return "VK_PIPELINE_BIND_POINT_GRAPHICS";
3186 case VK_PIPELINE_BIND_POINT_RAY_TRACING_NV:
3187 return "VK_PIPELINE_BIND_POINT_RAY_TRACING_NV";
3188 default:
3189 return "Unhandled VkPipelineBindPoint";
3190 }
3191 }
3192
string_VkAccessFlagBits(VkAccessFlagBits input_value)3193 static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value)
3194 {
3195 switch ((VkAccessFlagBits)input_value)
3196 {
3197 case VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV:
3198 return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV";
3199 case VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV:
3200 return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV";
3201 case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
3202 return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
3203 case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
3204 return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
3205 case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
3206 return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
3207 case VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX:
3208 return "VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX";
3209 case VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX:
3210 return "VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX";
3211 case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
3212 return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
3213 case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
3214 return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
3215 case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
3216 return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
3217 case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
3218 return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
3219 case VK_ACCESS_HOST_READ_BIT:
3220 return "VK_ACCESS_HOST_READ_BIT";
3221 case VK_ACCESS_HOST_WRITE_BIT:
3222 return "VK_ACCESS_HOST_WRITE_BIT";
3223 case VK_ACCESS_INDEX_READ_BIT:
3224 return "VK_ACCESS_INDEX_READ_BIT";
3225 case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
3226 return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
3227 case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
3228 return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
3229 case VK_ACCESS_MEMORY_READ_BIT:
3230 return "VK_ACCESS_MEMORY_READ_BIT";
3231 case VK_ACCESS_MEMORY_WRITE_BIT:
3232 return "VK_ACCESS_MEMORY_WRITE_BIT";
3233 case VK_ACCESS_SHADER_READ_BIT:
3234 return "VK_ACCESS_SHADER_READ_BIT";
3235 case VK_ACCESS_SHADER_WRITE_BIT:
3236 return "VK_ACCESS_SHADER_WRITE_BIT";
3237 case VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV:
3238 return "VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV";
3239 case VK_ACCESS_TRANSFER_READ_BIT:
3240 return "VK_ACCESS_TRANSFER_READ_BIT";
3241 case VK_ACCESS_TRANSFER_WRITE_BIT:
3242 return "VK_ACCESS_TRANSFER_WRITE_BIT";
3243 case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
3244 return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
3245 case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
3246 return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
3247 case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
3248 return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
3249 case VK_ACCESS_UNIFORM_READ_BIT:
3250 return "VK_ACCESS_UNIFORM_READ_BIT";
3251 case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
3252 return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
3253 default:
3254 return "Unhandled VkAccessFlagBits";
3255 }
3256 }
3257
string_VkAccessFlags(VkAccessFlags input_value)3258 static inline std::string string_VkAccessFlags(VkAccessFlags input_value)
3259 {
3260 std::string ret;
3261 int index = 0;
3262 while(input_value) {
3263 if (input_value & 1) {
3264 if( !ret.empty()) ret.append("|");
3265 ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(1 << index)));
3266 }
3267 ++index;
3268 input_value >>= 1;
3269 }
3270 if( ret.empty()) ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(0)));
3271 return ret;
3272 }
3273
string_VkDependencyFlagBits(VkDependencyFlagBits input_value)3274 static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input_value)
3275 {
3276 switch ((VkDependencyFlagBits)input_value)
3277 {
3278 case VK_DEPENDENCY_BY_REGION_BIT:
3279 return "VK_DEPENDENCY_BY_REGION_BIT";
3280 case VK_DEPENDENCY_DEVICE_GROUP_BIT:
3281 return "VK_DEPENDENCY_DEVICE_GROUP_BIT";
3282 case VK_DEPENDENCY_VIEW_LOCAL_BIT:
3283 return "VK_DEPENDENCY_VIEW_LOCAL_BIT";
3284 default:
3285 return "Unhandled VkDependencyFlagBits";
3286 }
3287 }
3288
string_VkDependencyFlags(VkDependencyFlags input_value)3289 static inline std::string string_VkDependencyFlags(VkDependencyFlags input_value)
3290 {
3291 std::string ret;
3292 int index = 0;
3293 while(input_value) {
3294 if (input_value & 1) {
3295 if( !ret.empty()) ret.append("|");
3296 ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(1 << index)));
3297 }
3298 ++index;
3299 input_value >>= 1;
3300 }
3301 if( ret.empty()) ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(0)));
3302 return ret;
3303 }
3304
string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)3305 static inline const char* string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)
3306 {
3307 switch ((VkCommandPoolCreateFlagBits)input_value)
3308 {
3309 case VK_COMMAND_POOL_CREATE_PROTECTED_BIT:
3310 return "VK_COMMAND_POOL_CREATE_PROTECTED_BIT";
3311 case VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT:
3312 return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT";
3313 case VK_COMMAND_POOL_CREATE_TRANSIENT_BIT:
3314 return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT";
3315 default:
3316 return "Unhandled VkCommandPoolCreateFlagBits";
3317 }
3318 }
3319
string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value)3320 static inline std::string string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value)
3321 {
3322 std::string ret;
3323 int index = 0;
3324 while(input_value) {
3325 if (input_value & 1) {
3326 if( !ret.empty()) ret.append("|");
3327 ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(1 << index)));
3328 }
3329 ++index;
3330 input_value >>= 1;
3331 }
3332 if( ret.empty()) ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(0)));
3333 return ret;
3334 }
3335
string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)3336 static inline const char* string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)
3337 {
3338 switch ((VkCommandPoolResetFlagBits)input_value)
3339 {
3340 case VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT:
3341 return "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT";
3342 default:
3343 return "Unhandled VkCommandPoolResetFlagBits";
3344 }
3345 }
3346
string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value)3347 static inline std::string string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value)
3348 {
3349 std::string ret;
3350 int index = 0;
3351 while(input_value) {
3352 if (input_value & 1) {
3353 if( !ret.empty()) ret.append("|");
3354 ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(1 << index)));
3355 }
3356 ++index;
3357 input_value >>= 1;
3358 }
3359 if( ret.empty()) ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(0)));
3360 return ret;
3361 }
3362
string_VkCommandBufferLevel(VkCommandBufferLevel input_value)3363 static inline const char* string_VkCommandBufferLevel(VkCommandBufferLevel input_value)
3364 {
3365 switch ((VkCommandBufferLevel)input_value)
3366 {
3367 case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
3368 return "VK_COMMAND_BUFFER_LEVEL_PRIMARY";
3369 case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
3370 return "VK_COMMAND_BUFFER_LEVEL_SECONDARY";
3371 default:
3372 return "Unhandled VkCommandBufferLevel";
3373 }
3374 }
3375
string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)3376 static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)
3377 {
3378 switch ((VkCommandBufferUsageFlagBits)input_value)
3379 {
3380 case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
3381 return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
3382 case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
3383 return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
3384 case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
3385 return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
3386 default:
3387 return "Unhandled VkCommandBufferUsageFlagBits";
3388 }
3389 }
3390
string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value)3391 static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value)
3392 {
3393 std::string ret;
3394 int index = 0;
3395 while(input_value) {
3396 if (input_value & 1) {
3397 if( !ret.empty()) ret.append("|");
3398 ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(1 << index)));
3399 }
3400 ++index;
3401 input_value >>= 1;
3402 }
3403 if( ret.empty()) ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(0)));
3404 return ret;
3405 }
3406
string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)3407 static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)
3408 {
3409 switch ((VkQueryControlFlagBits)input_value)
3410 {
3411 case VK_QUERY_CONTROL_PRECISE_BIT:
3412 return "VK_QUERY_CONTROL_PRECISE_BIT";
3413 default:
3414 return "Unhandled VkQueryControlFlagBits";
3415 }
3416 }
3417
string_VkQueryControlFlags(VkQueryControlFlags input_value)3418 static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value)
3419 {
3420 std::string ret;
3421 int index = 0;
3422 while(input_value) {
3423 if (input_value & 1) {
3424 if( !ret.empty()) ret.append("|");
3425 ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(1 << index)));
3426 }
3427 ++index;
3428 input_value >>= 1;
3429 }
3430 if( ret.empty()) ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(0)));
3431 return ret;
3432 }
3433
string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)3434 static inline const char* string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)
3435 {
3436 switch ((VkCommandBufferResetFlagBits)input_value)
3437 {
3438 case VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT:
3439 return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT";
3440 default:
3441 return "Unhandled VkCommandBufferResetFlagBits";
3442 }
3443 }
3444
string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value)3445 static inline std::string string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value)
3446 {
3447 std::string ret;
3448 int index = 0;
3449 while(input_value) {
3450 if (input_value & 1) {
3451 if( !ret.empty()) ret.append("|");
3452 ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(1 << index)));
3453 }
3454 ++index;
3455 input_value >>= 1;
3456 }
3457 if( ret.empty()) ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(0)));
3458 return ret;
3459 }
3460
string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)3461 static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)
3462 {
3463 switch ((VkStencilFaceFlagBits)input_value)
3464 {
3465 case VK_STENCIL_FACE_BACK_BIT:
3466 return "VK_STENCIL_FACE_BACK_BIT";
3467 case VK_STENCIL_FACE_FRONT_AND_BACK:
3468 return "VK_STENCIL_FACE_FRONT_AND_BACK";
3469 case VK_STENCIL_FACE_FRONT_BIT:
3470 return "VK_STENCIL_FACE_FRONT_BIT";
3471 default:
3472 return "Unhandled VkStencilFaceFlagBits";
3473 }
3474 }
3475
string_VkStencilFaceFlags(VkStencilFaceFlags input_value)3476 static inline std::string string_VkStencilFaceFlags(VkStencilFaceFlags input_value)
3477 {
3478 std::string ret;
3479 int index = 0;
3480 while(input_value) {
3481 if (input_value & 1) {
3482 if( !ret.empty()) ret.append("|");
3483 ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(1 << index)));
3484 }
3485 ++index;
3486 input_value >>= 1;
3487 }
3488 if( ret.empty()) ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(0)));
3489 return ret;
3490 }
3491
string_VkIndexType(VkIndexType input_value)3492 static inline const char* string_VkIndexType(VkIndexType input_value)
3493 {
3494 switch ((VkIndexType)input_value)
3495 {
3496 case VK_INDEX_TYPE_NONE_NV:
3497 return "VK_INDEX_TYPE_NONE_NV";
3498 case VK_INDEX_TYPE_UINT16:
3499 return "VK_INDEX_TYPE_UINT16";
3500 case VK_INDEX_TYPE_UINT32:
3501 return "VK_INDEX_TYPE_UINT32";
3502 case VK_INDEX_TYPE_UINT8_EXT:
3503 return "VK_INDEX_TYPE_UINT8_EXT";
3504 default:
3505 return "Unhandled VkIndexType";
3506 }
3507 }
3508
string_VkSubpassContents(VkSubpassContents input_value)3509 static inline const char* string_VkSubpassContents(VkSubpassContents input_value)
3510 {
3511 switch ((VkSubpassContents)input_value)
3512 {
3513 case VK_SUBPASS_CONTENTS_INLINE:
3514 return "VK_SUBPASS_CONTENTS_INLINE";
3515 case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
3516 return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS";
3517 default:
3518 return "Unhandled VkSubpassContents";
3519 }
3520 }
3521
string_VkObjectType(VkObjectType input_value)3522 static inline const char* string_VkObjectType(VkObjectType input_value)
3523 {
3524 switch ((VkObjectType)input_value)
3525 {
3526 case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV:
3527 return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV";
3528 case VK_OBJECT_TYPE_BUFFER:
3529 return "VK_OBJECT_TYPE_BUFFER";
3530 case VK_OBJECT_TYPE_BUFFER_VIEW:
3531 return "VK_OBJECT_TYPE_BUFFER_VIEW";
3532 case VK_OBJECT_TYPE_COMMAND_BUFFER:
3533 return "VK_OBJECT_TYPE_COMMAND_BUFFER";
3534 case VK_OBJECT_TYPE_COMMAND_POOL:
3535 return "VK_OBJECT_TYPE_COMMAND_POOL";
3536 case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
3537 return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
3538 case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
3539 return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT";
3540 case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
3541 return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
3542 case VK_OBJECT_TYPE_DESCRIPTOR_SET:
3543 return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
3544 case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
3545 return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
3546 case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
3547 return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE";
3548 case VK_OBJECT_TYPE_DEVICE:
3549 return "VK_OBJECT_TYPE_DEVICE";
3550 case VK_OBJECT_TYPE_DEVICE_MEMORY:
3551 return "VK_OBJECT_TYPE_DEVICE_MEMORY";
3552 case VK_OBJECT_TYPE_DISPLAY_KHR:
3553 return "VK_OBJECT_TYPE_DISPLAY_KHR";
3554 case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
3555 return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
3556 case VK_OBJECT_TYPE_EVENT:
3557 return "VK_OBJECT_TYPE_EVENT";
3558 case VK_OBJECT_TYPE_FENCE:
3559 return "VK_OBJECT_TYPE_FENCE";
3560 case VK_OBJECT_TYPE_FRAMEBUFFER:
3561 return "VK_OBJECT_TYPE_FRAMEBUFFER";
3562 case VK_OBJECT_TYPE_IMAGE:
3563 return "VK_OBJECT_TYPE_IMAGE";
3564 case VK_OBJECT_TYPE_IMAGE_VIEW:
3565 return "VK_OBJECT_TYPE_IMAGE_VIEW";
3566 case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX:
3567 return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX";
3568 case VK_OBJECT_TYPE_INSTANCE:
3569 return "VK_OBJECT_TYPE_INSTANCE";
3570 case VK_OBJECT_TYPE_OBJECT_TABLE_NVX:
3571 return "VK_OBJECT_TYPE_OBJECT_TABLE_NVX";
3572 case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL:
3573 return "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL";
3574 case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
3575 return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
3576 case VK_OBJECT_TYPE_PIPELINE:
3577 return "VK_OBJECT_TYPE_PIPELINE";
3578 case VK_OBJECT_TYPE_PIPELINE_CACHE:
3579 return "VK_OBJECT_TYPE_PIPELINE_CACHE";
3580 case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
3581 return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
3582 case VK_OBJECT_TYPE_QUERY_POOL:
3583 return "VK_OBJECT_TYPE_QUERY_POOL";
3584 case VK_OBJECT_TYPE_QUEUE:
3585 return "VK_OBJECT_TYPE_QUEUE";
3586 case VK_OBJECT_TYPE_RENDER_PASS:
3587 return "VK_OBJECT_TYPE_RENDER_PASS";
3588 case VK_OBJECT_TYPE_SAMPLER:
3589 return "VK_OBJECT_TYPE_SAMPLER";
3590 case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
3591 return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION";
3592 case VK_OBJECT_TYPE_SEMAPHORE:
3593 return "VK_OBJECT_TYPE_SEMAPHORE";
3594 case VK_OBJECT_TYPE_SHADER_MODULE:
3595 return "VK_OBJECT_TYPE_SHADER_MODULE";
3596 case VK_OBJECT_TYPE_SURFACE_KHR:
3597 return "VK_OBJECT_TYPE_SURFACE_KHR";
3598 case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
3599 return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
3600 case VK_OBJECT_TYPE_UNKNOWN:
3601 return "VK_OBJECT_TYPE_UNKNOWN";
3602 case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT:
3603 return "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT";
3604 default:
3605 return "Unhandled VkObjectType";
3606 }
3607 }
3608
string_VkVendorId(VkVendorId input_value)3609 static inline const char* string_VkVendorId(VkVendorId input_value)
3610 {
3611 switch ((VkVendorId)input_value)
3612 {
3613 case VK_VENDOR_ID_KAZAN:
3614 return "VK_VENDOR_ID_KAZAN";
3615 case VK_VENDOR_ID_VIV:
3616 return "VK_VENDOR_ID_VIV";
3617 case VK_VENDOR_ID_VSI:
3618 return "VK_VENDOR_ID_VSI";
3619 default:
3620 return "Unhandled VkVendorId";
3621 }
3622 }
3623
string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value)3624 static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value)
3625 {
3626 switch ((VkSubgroupFeatureFlagBits)input_value)
3627 {
3628 case VK_SUBGROUP_FEATURE_ARITHMETIC_BIT:
3629 return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
3630 case VK_SUBGROUP_FEATURE_BALLOT_BIT:
3631 return "VK_SUBGROUP_FEATURE_BALLOT_BIT";
3632 case VK_SUBGROUP_FEATURE_BASIC_BIT:
3633 return "VK_SUBGROUP_FEATURE_BASIC_BIT";
3634 case VK_SUBGROUP_FEATURE_CLUSTERED_BIT:
3635 return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
3636 case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
3637 return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
3638 case VK_SUBGROUP_FEATURE_QUAD_BIT:
3639 return "VK_SUBGROUP_FEATURE_QUAD_BIT";
3640 case VK_SUBGROUP_FEATURE_SHUFFLE_BIT:
3641 return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
3642 case VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT:
3643 return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
3644 case VK_SUBGROUP_FEATURE_VOTE_BIT:
3645 return "VK_SUBGROUP_FEATURE_VOTE_BIT";
3646 default:
3647 return "Unhandled VkSubgroupFeatureFlagBits";
3648 }
3649 }
3650
string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value)3651 static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value)
3652 {
3653 std::string ret;
3654 int index = 0;
3655 while(input_value) {
3656 if (input_value & 1) {
3657 if( !ret.empty()) ret.append("|");
3658 ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(1 << index)));
3659 }
3660 ++index;
3661 input_value >>= 1;
3662 }
3663 if( ret.empty()) ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(0)));
3664 return ret;
3665 }
3666
string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value)3667 static inline const char* string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value)
3668 {
3669 switch ((VkPeerMemoryFeatureFlagBits)input_value)
3670 {
3671 case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
3672 return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
3673 case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
3674 return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
3675 case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
3676 return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
3677 case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
3678 return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
3679 default:
3680 return "Unhandled VkPeerMemoryFeatureFlagBits";
3681 }
3682 }
3683
string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value)3684 static inline std::string string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value)
3685 {
3686 std::string ret;
3687 int index = 0;
3688 while(input_value) {
3689 if (input_value & 1) {
3690 if( !ret.empty()) ret.append("|");
3691 ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(1 << index)));
3692 }
3693 ++index;
3694 input_value >>= 1;
3695 }
3696 if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(0)));
3697 return ret;
3698 }
3699
string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits input_value)3700 static inline const char* string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits input_value)
3701 {
3702 switch ((VkMemoryAllocateFlagBits)input_value)
3703 {
3704 case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
3705 return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
3706 default:
3707 return "Unhandled VkMemoryAllocateFlagBits";
3708 }
3709 }
3710
string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value)3711 static inline std::string string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value)
3712 {
3713 std::string ret;
3714 int index = 0;
3715 while(input_value) {
3716 if (input_value & 1) {
3717 if( !ret.empty()) ret.append("|");
3718 ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(1 << index)));
3719 }
3720 ++index;
3721 input_value >>= 1;
3722 }
3723 if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(0)));
3724 return ret;
3725 }
3726
string_VkPointClippingBehavior(VkPointClippingBehavior input_value)3727 static inline const char* string_VkPointClippingBehavior(VkPointClippingBehavior input_value)
3728 {
3729 switch ((VkPointClippingBehavior)input_value)
3730 {
3731 case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
3732 return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
3733 case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
3734 return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
3735 default:
3736 return "Unhandled VkPointClippingBehavior";
3737 }
3738 }
3739
string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value)3740 static inline const char* string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value)
3741 {
3742 switch ((VkTessellationDomainOrigin)input_value)
3743 {
3744 case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
3745 return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
3746 case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
3747 return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
3748 default:
3749 return "Unhandled VkTessellationDomainOrigin";
3750 }
3751 }
3752
string_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion input_value)3753 static inline const char* string_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion input_value)
3754 {
3755 switch ((VkSamplerYcbcrModelConversion)input_value)
3756 {
3757 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
3758 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
3759 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
3760 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
3761 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
3762 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
3763 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
3764 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
3765 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
3766 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
3767 default:
3768 return "Unhandled VkSamplerYcbcrModelConversion";
3769 }
3770 }
3771
string_VkSamplerYcbcrRange(VkSamplerYcbcrRange input_value)3772 static inline const char* string_VkSamplerYcbcrRange(VkSamplerYcbcrRange input_value)
3773 {
3774 switch ((VkSamplerYcbcrRange)input_value)
3775 {
3776 case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
3777 return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
3778 case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
3779 return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
3780 default:
3781 return "Unhandled VkSamplerYcbcrRange";
3782 }
3783 }
3784
string_VkChromaLocation(VkChromaLocation input_value)3785 static inline const char* string_VkChromaLocation(VkChromaLocation input_value)
3786 {
3787 switch ((VkChromaLocation)input_value)
3788 {
3789 case VK_CHROMA_LOCATION_COSITED_EVEN:
3790 return "VK_CHROMA_LOCATION_COSITED_EVEN";
3791 case VK_CHROMA_LOCATION_MIDPOINT:
3792 return "VK_CHROMA_LOCATION_MIDPOINT";
3793 default:
3794 return "Unhandled VkChromaLocation";
3795 }
3796 }
3797
string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value)3798 static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value)
3799 {
3800 switch ((VkDescriptorUpdateTemplateType)input_value)
3801 {
3802 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
3803 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
3804 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
3805 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
3806 default:
3807 return "Unhandled VkDescriptorUpdateTemplateType";
3808 }
3809 }
3810
string_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits input_value)3811 static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits input_value)
3812 {
3813 switch ((VkExternalMemoryHandleTypeFlagBits)input_value)
3814 {
3815 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
3816 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
3817 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
3818 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
3819 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
3820 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
3821 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
3822 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
3823 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
3824 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
3825 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
3826 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
3827 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
3828 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
3829 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
3830 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
3831 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
3832 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
3833 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
3834 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
3835 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
3836 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
3837 default:
3838 return "Unhandled VkExternalMemoryHandleTypeFlagBits";
3839 }
3840 }
3841
string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value)3842 static inline std::string string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value)
3843 {
3844 std::string ret;
3845 int index = 0;
3846 while(input_value) {
3847 if (input_value & 1) {
3848 if( !ret.empty()) ret.append("|");
3849 ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(1 << index)));
3850 }
3851 ++index;
3852 input_value >>= 1;
3853 }
3854 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(0)));
3855 return ret;
3856 }
3857
string_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits input_value)3858 static inline const char* string_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits input_value)
3859 {
3860 switch ((VkExternalMemoryFeatureFlagBits)input_value)
3861 {
3862 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
3863 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
3864 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
3865 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
3866 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
3867 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
3868 default:
3869 return "Unhandled VkExternalMemoryFeatureFlagBits";
3870 }
3871 }
3872
string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value)3873 static inline std::string string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value)
3874 {
3875 std::string ret;
3876 int index = 0;
3877 while(input_value) {
3878 if (input_value & 1) {
3879 if( !ret.empty()) ret.append("|");
3880 ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(1 << index)));
3881 }
3882 ++index;
3883 input_value >>= 1;
3884 }
3885 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(0)));
3886 return ret;
3887 }
3888
string_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits input_value)3889 static inline const char* string_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits input_value)
3890 {
3891 switch ((VkExternalFenceHandleTypeFlagBits)input_value)
3892 {
3893 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
3894 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
3895 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
3896 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
3897 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
3898 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
3899 case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
3900 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
3901 default:
3902 return "Unhandled VkExternalFenceHandleTypeFlagBits";
3903 }
3904 }
3905
string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value)3906 static inline std::string string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value)
3907 {
3908 std::string ret;
3909 int index = 0;
3910 while(input_value) {
3911 if (input_value & 1) {
3912 if( !ret.empty()) ret.append("|");
3913 ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(1 << index)));
3914 }
3915 ++index;
3916 input_value >>= 1;
3917 }
3918 if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(0)));
3919 return ret;
3920 }
3921
string_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits input_value)3922 static inline const char* string_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits input_value)
3923 {
3924 switch ((VkExternalFenceFeatureFlagBits)input_value)
3925 {
3926 case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
3927 return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
3928 case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
3929 return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
3930 default:
3931 return "Unhandled VkExternalFenceFeatureFlagBits";
3932 }
3933 }
3934
string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value)3935 static inline std::string string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value)
3936 {
3937 std::string ret;
3938 int index = 0;
3939 while(input_value) {
3940 if (input_value & 1) {
3941 if( !ret.empty()) ret.append("|");
3942 ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(1 << index)));
3943 }
3944 ++index;
3945 input_value >>= 1;
3946 }
3947 if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(0)));
3948 return ret;
3949 }
3950
string_VkFenceImportFlagBits(VkFenceImportFlagBits input_value)3951 static inline const char* string_VkFenceImportFlagBits(VkFenceImportFlagBits input_value)
3952 {
3953 switch ((VkFenceImportFlagBits)input_value)
3954 {
3955 case VK_FENCE_IMPORT_TEMPORARY_BIT:
3956 return "VK_FENCE_IMPORT_TEMPORARY_BIT";
3957 default:
3958 return "Unhandled VkFenceImportFlagBits";
3959 }
3960 }
3961
string_VkFenceImportFlags(VkFenceImportFlags input_value)3962 static inline std::string string_VkFenceImportFlags(VkFenceImportFlags input_value)
3963 {
3964 std::string ret;
3965 int index = 0;
3966 while(input_value) {
3967 if (input_value & 1) {
3968 if( !ret.empty()) ret.append("|");
3969 ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(1 << index)));
3970 }
3971 ++index;
3972 input_value >>= 1;
3973 }
3974 if( ret.empty()) ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(0)));
3975 return ret;
3976 }
3977
string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits input_value)3978 static inline const char* string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits input_value)
3979 {
3980 switch ((VkSemaphoreImportFlagBits)input_value)
3981 {
3982 case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
3983 return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
3984 default:
3985 return "Unhandled VkSemaphoreImportFlagBits";
3986 }
3987 }
3988
string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value)3989 static inline std::string string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value)
3990 {
3991 std::string ret;
3992 int index = 0;
3993 while(input_value) {
3994 if (input_value & 1) {
3995 if( !ret.empty()) ret.append("|");
3996 ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(1 << index)));
3997 }
3998 ++index;
3999 input_value >>= 1;
4000 }
4001 if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(0)));
4002 return ret;
4003 }
4004
string_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits input_value)4005 static inline const char* string_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits input_value)
4006 {
4007 switch ((VkExternalSemaphoreHandleTypeFlagBits)input_value)
4008 {
4009 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
4010 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
4011 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
4012 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
4013 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4014 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4015 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4016 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4017 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
4018 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
4019 default:
4020 return "Unhandled VkExternalSemaphoreHandleTypeFlagBits";
4021 }
4022 }
4023
string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value)4024 static inline std::string string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value)
4025 {
4026 std::string ret;
4027 int index = 0;
4028 while(input_value) {
4029 if (input_value & 1) {
4030 if( !ret.empty()) ret.append("|");
4031 ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(1 << index)));
4032 }
4033 ++index;
4034 input_value >>= 1;
4035 }
4036 if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(0)));
4037 return ret;
4038 }
4039
string_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits input_value)4040 static inline const char* string_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits input_value)
4041 {
4042 switch ((VkExternalSemaphoreFeatureFlagBits)input_value)
4043 {
4044 case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
4045 return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
4046 case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
4047 return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
4048 default:
4049 return "Unhandled VkExternalSemaphoreFeatureFlagBits";
4050 }
4051 }
4052
string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value)4053 static inline std::string string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value)
4054 {
4055 std::string ret;
4056 int index = 0;
4057 while(input_value) {
4058 if (input_value & 1) {
4059 if( !ret.empty()) ret.append("|");
4060 ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(1 << index)));
4061 }
4062 ++index;
4063 input_value >>= 1;
4064 }
4065 if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(0)));
4066 return ret;
4067 }
4068
string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)4069 static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)
4070 {
4071 switch ((VkSurfaceTransformFlagBitsKHR)input_value)
4072 {
4073 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
4074 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR";
4075 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
4076 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR";
4077 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
4078 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR";
4079 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
4080 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR";
4081 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
4082 return "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR";
4083 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
4084 return "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR";
4085 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
4086 return "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR";
4087 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
4088 return "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR";
4089 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
4090 return "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR";
4091 default:
4092 return "Unhandled VkSurfaceTransformFlagBitsKHR";
4093 }
4094 }
4095
string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value)4096 static inline std::string string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value)
4097 {
4098 std::string ret;
4099 int index = 0;
4100 while(input_value) {
4101 if (input_value & 1) {
4102 if( !ret.empty()) ret.append("|");
4103 ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(1 << index)));
4104 }
4105 ++index;
4106 input_value >>= 1;
4107 }
4108 if( ret.empty()) ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(0)));
4109 return ret;
4110 }
4111
string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)4112 static inline const char* string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)
4113 {
4114 switch ((VkCompositeAlphaFlagBitsKHR)input_value)
4115 {
4116 case VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR:
4117 return "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR";
4118 case VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR:
4119 return "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR";
4120 case VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR:
4121 return "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR";
4122 case VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR:
4123 return "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR";
4124 default:
4125 return "Unhandled VkCompositeAlphaFlagBitsKHR";
4126 }
4127 }
4128
string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value)4129 static inline std::string string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value)
4130 {
4131 std::string ret;
4132 int index = 0;
4133 while(input_value) {
4134 if (input_value & 1) {
4135 if( !ret.empty()) ret.append("|");
4136 ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(1 << index)));
4137 }
4138 ++index;
4139 input_value >>= 1;
4140 }
4141 if( ret.empty()) ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(0)));
4142 return ret;
4143 }
4144
string_VkColorSpaceKHR(VkColorSpaceKHR input_value)4145 static inline const char* string_VkColorSpaceKHR(VkColorSpaceKHR input_value)
4146 {
4147 switch ((VkColorSpaceKHR)input_value)
4148 {
4149 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
4150 return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT";
4151 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
4152 return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
4153 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
4154 return "VK_COLOR_SPACE_BT2020_LINEAR_EXT";
4155 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
4156 return "VK_COLOR_SPACE_BT709_LINEAR_EXT";
4157 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
4158 return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT";
4159 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
4160 return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
4161 case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD:
4162 return "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD";
4163 case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT:
4164 return "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
4165 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
4166 return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
4167 case VK_COLOR_SPACE_DOLBYVISION_EXT:
4168 return "VK_COLOR_SPACE_DOLBYVISION_EXT";
4169 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
4170 return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
4171 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
4172 return "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
4173 case VK_COLOR_SPACE_HDR10_HLG_EXT:
4174 return "VK_COLOR_SPACE_HDR10_HLG_EXT";
4175 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
4176 return "VK_COLOR_SPACE_HDR10_ST2084_EXT";
4177 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
4178 return "VK_COLOR_SPACE_PASS_THROUGH_EXT";
4179 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
4180 return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
4181 default:
4182 return "Unhandled VkColorSpaceKHR";
4183 }
4184 }
4185
string_VkPresentModeKHR(VkPresentModeKHR input_value)4186 static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value)
4187 {
4188 switch ((VkPresentModeKHR)input_value)
4189 {
4190 case VK_PRESENT_MODE_FIFO_KHR:
4191 return "VK_PRESENT_MODE_FIFO_KHR";
4192 case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
4193 return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
4194 case VK_PRESENT_MODE_IMMEDIATE_KHR:
4195 return "VK_PRESENT_MODE_IMMEDIATE_KHR";
4196 case VK_PRESENT_MODE_MAILBOX_KHR:
4197 return "VK_PRESENT_MODE_MAILBOX_KHR";
4198 case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
4199 return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
4200 case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
4201 return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
4202 default:
4203 return "Unhandled VkPresentModeKHR";
4204 }
4205 }
4206
string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)4207 static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)
4208 {
4209 switch ((VkSwapchainCreateFlagBitsKHR)input_value)
4210 {
4211 case VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR:
4212 return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
4213 case VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR:
4214 return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR";
4215 case VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR:
4216 return "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR";
4217 default:
4218 return "Unhandled VkSwapchainCreateFlagBitsKHR";
4219 }
4220 }
4221
string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value)4222 static inline std::string string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value)
4223 {
4224 std::string ret;
4225 int index = 0;
4226 while(input_value) {
4227 if (input_value & 1) {
4228 if( !ret.empty()) ret.append("|");
4229 ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(1 << index)));
4230 }
4231 ++index;
4232 input_value >>= 1;
4233 }
4234 if( ret.empty()) ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(0)));
4235 return ret;
4236 }
4237
string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR input_value)4238 static inline const char* string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR input_value)
4239 {
4240 switch ((VkDeviceGroupPresentModeFlagBitsKHR)input_value)
4241 {
4242 case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR:
4243 return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR";
4244 case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR:
4245 return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR";
4246 case VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR:
4247 return "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR";
4248 case VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR:
4249 return "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR";
4250 default:
4251 return "Unhandled VkDeviceGroupPresentModeFlagBitsKHR";
4252 }
4253 }
4254
string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value)4255 static inline std::string string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value)
4256 {
4257 std::string ret;
4258 int index = 0;
4259 while(input_value) {
4260 if (input_value & 1) {
4261 if( !ret.empty()) ret.append("|");
4262 ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(1 << index)));
4263 }
4264 ++index;
4265 input_value >>= 1;
4266 }
4267 if( ret.empty()) ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(0)));
4268 return ret;
4269 }
4270
string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)4271 static inline const char* string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)
4272 {
4273 switch ((VkDisplayPlaneAlphaFlagBitsKHR)input_value)
4274 {
4275 case VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR:
4276 return "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR";
4277 case VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR:
4278 return "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR";
4279 case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR:
4280 return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR";
4281 case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR:
4282 return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR";
4283 default:
4284 return "Unhandled VkDisplayPlaneAlphaFlagBitsKHR";
4285 }
4286 }
4287
string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value)4288 static inline std::string string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value)
4289 {
4290 std::string ret;
4291 int index = 0;
4292 while(input_value) {
4293 if (input_value & 1) {
4294 if( !ret.empty()) ret.append("|");
4295 ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(1 << index)));
4296 }
4297 ++index;
4298 input_value >>= 1;
4299 }
4300 if( ret.empty()) ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(0)));
4301 return ret;
4302 }
4303
string_VkPeerMemoryFeatureFlagBitsKHR(VkPeerMemoryFeatureFlagBitsKHR input_value)4304 static inline const char* string_VkPeerMemoryFeatureFlagBitsKHR(VkPeerMemoryFeatureFlagBitsKHR input_value)
4305 {
4306 switch ((VkPeerMemoryFeatureFlagBitsKHR)input_value)
4307 {
4308 case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
4309 return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
4310 case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
4311 return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
4312 case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
4313 return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
4314 case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
4315 return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
4316 default:
4317 return "Unhandled VkPeerMemoryFeatureFlagBitsKHR";
4318 }
4319 }
4320
string_VkPeerMemoryFeatureFlagsKHR(VkPeerMemoryFeatureFlagsKHR input_value)4321 static inline std::string string_VkPeerMemoryFeatureFlagsKHR(VkPeerMemoryFeatureFlagsKHR input_value)
4322 {
4323 std::string ret;
4324 int index = 0;
4325 while(input_value) {
4326 if (input_value & 1) {
4327 if( !ret.empty()) ret.append("|");
4328 ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(1 << index)));
4329 }
4330 ++index;
4331 input_value >>= 1;
4332 }
4333 if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(0)));
4334 return ret;
4335 }
4336
string_VkMemoryAllocateFlagBitsKHR(VkMemoryAllocateFlagBitsKHR input_value)4337 static inline const char* string_VkMemoryAllocateFlagBitsKHR(VkMemoryAllocateFlagBitsKHR input_value)
4338 {
4339 switch ((VkMemoryAllocateFlagBitsKHR)input_value)
4340 {
4341 case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
4342 return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
4343 default:
4344 return "Unhandled VkMemoryAllocateFlagBitsKHR";
4345 }
4346 }
4347
string_VkMemoryAllocateFlagsKHR(VkMemoryAllocateFlagsKHR input_value)4348 static inline std::string string_VkMemoryAllocateFlagsKHR(VkMemoryAllocateFlagsKHR input_value)
4349 {
4350 std::string ret;
4351 int index = 0;
4352 while(input_value) {
4353 if (input_value & 1) {
4354 if( !ret.empty()) ret.append("|");
4355 ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(1 << index)));
4356 }
4357 ++index;
4358 input_value >>= 1;
4359 }
4360 if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(0)));
4361 return ret;
4362 }
4363
string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)4364 static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)
4365 {
4366 switch ((VkExternalMemoryHandleTypeFlagBitsKHR)input_value)
4367 {
4368 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
4369 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
4370 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
4371 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
4372 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
4373 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
4374 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
4375 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
4376 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
4377 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
4378 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
4379 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
4380 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
4381 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
4382 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
4383 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
4384 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
4385 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
4386 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4387 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4388 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4389 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4390 default:
4391 return "Unhandled VkExternalMemoryHandleTypeFlagBitsKHR";
4392 }
4393 }
4394
string_VkExternalMemoryHandleTypeFlagsKHR(VkExternalMemoryHandleTypeFlagsKHR input_value)4395 static inline std::string string_VkExternalMemoryHandleTypeFlagsKHR(VkExternalMemoryHandleTypeFlagsKHR input_value)
4396 {
4397 std::string ret;
4398 int index = 0;
4399 while(input_value) {
4400 if (input_value & 1) {
4401 if( !ret.empty()) ret.append("|");
4402 ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(1 << index)));
4403 }
4404 ++index;
4405 input_value >>= 1;
4406 }
4407 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(0)));
4408 return ret;
4409 }
4410
string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)4411 static inline const char* string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)
4412 {
4413 switch ((VkExternalMemoryFeatureFlagBitsKHR)input_value)
4414 {
4415 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
4416 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
4417 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
4418 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
4419 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
4420 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
4421 default:
4422 return "Unhandled VkExternalMemoryFeatureFlagBitsKHR";
4423 }
4424 }
4425
string_VkExternalMemoryFeatureFlagsKHR(VkExternalMemoryFeatureFlagsKHR input_value)4426 static inline std::string string_VkExternalMemoryFeatureFlagsKHR(VkExternalMemoryFeatureFlagsKHR input_value)
4427 {
4428 std::string ret;
4429 int index = 0;
4430 while(input_value) {
4431 if (input_value & 1) {
4432 if( !ret.empty()) ret.append("|");
4433 ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(1 << index)));
4434 }
4435 ++index;
4436 input_value >>= 1;
4437 }
4438 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(0)));
4439 return ret;
4440 }
4441
string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)4442 static inline const char* string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)
4443 {
4444 switch ((VkExternalSemaphoreHandleTypeFlagBitsKHR)input_value)
4445 {
4446 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
4447 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
4448 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
4449 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
4450 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4451 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4452 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4453 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4454 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
4455 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
4456 default:
4457 return "Unhandled VkExternalSemaphoreHandleTypeFlagBitsKHR";
4458 }
4459 }
4460
string_VkExternalSemaphoreHandleTypeFlagsKHR(VkExternalSemaphoreHandleTypeFlagsKHR input_value)4461 static inline std::string string_VkExternalSemaphoreHandleTypeFlagsKHR(VkExternalSemaphoreHandleTypeFlagsKHR input_value)
4462 {
4463 std::string ret;
4464 int index = 0;
4465 while(input_value) {
4466 if (input_value & 1) {
4467 if( !ret.empty()) ret.append("|");
4468 ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(1 << index)));
4469 }
4470 ++index;
4471 input_value >>= 1;
4472 }
4473 if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(0)));
4474 return ret;
4475 }
4476
string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)4477 static inline const char* string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)
4478 {
4479 switch ((VkExternalSemaphoreFeatureFlagBitsKHR)input_value)
4480 {
4481 case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
4482 return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
4483 case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
4484 return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
4485 default:
4486 return "Unhandled VkExternalSemaphoreFeatureFlagBitsKHR";
4487 }
4488 }
4489
string_VkExternalSemaphoreFeatureFlagsKHR(VkExternalSemaphoreFeatureFlagsKHR input_value)4490 static inline std::string string_VkExternalSemaphoreFeatureFlagsKHR(VkExternalSemaphoreFeatureFlagsKHR input_value)
4491 {
4492 std::string ret;
4493 int index = 0;
4494 while(input_value) {
4495 if (input_value & 1) {
4496 if( !ret.empty()) ret.append("|");
4497 ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(1 << index)));
4498 }
4499 ++index;
4500 input_value >>= 1;
4501 }
4502 if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(0)));
4503 return ret;
4504 }
4505
string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)4506 static inline const char* string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)
4507 {
4508 switch ((VkSemaphoreImportFlagBitsKHR)input_value)
4509 {
4510 case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
4511 return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
4512 default:
4513 return "Unhandled VkSemaphoreImportFlagBitsKHR";
4514 }
4515 }
4516
string_VkSemaphoreImportFlagsKHR(VkSemaphoreImportFlagsKHR input_value)4517 static inline std::string string_VkSemaphoreImportFlagsKHR(VkSemaphoreImportFlagsKHR input_value)
4518 {
4519 std::string ret;
4520 int index = 0;
4521 while(input_value) {
4522 if (input_value & 1) {
4523 if( !ret.empty()) ret.append("|");
4524 ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(1 << index)));
4525 }
4526 ++index;
4527 input_value >>= 1;
4528 }
4529 if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(0)));
4530 return ret;
4531 }
4532
string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)4533 static inline const char* string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)
4534 {
4535 switch ((VkDescriptorUpdateTemplateTypeKHR)input_value)
4536 {
4537 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
4538 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
4539 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
4540 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
4541 default:
4542 return "Unhandled VkDescriptorUpdateTemplateTypeKHR";
4543 }
4544 }
4545
string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)4546 static inline const char* string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)
4547 {
4548 switch ((VkExternalFenceHandleTypeFlagBitsKHR)input_value)
4549 {
4550 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
4551 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
4552 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4553 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4554 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4555 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4556 case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
4557 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
4558 default:
4559 return "Unhandled VkExternalFenceHandleTypeFlagBitsKHR";
4560 }
4561 }
4562
string_VkExternalFenceHandleTypeFlagsKHR(VkExternalFenceHandleTypeFlagsKHR input_value)4563 static inline std::string string_VkExternalFenceHandleTypeFlagsKHR(VkExternalFenceHandleTypeFlagsKHR input_value)
4564 {
4565 std::string ret;
4566 int index = 0;
4567 while(input_value) {
4568 if (input_value & 1) {
4569 if( !ret.empty()) ret.append("|");
4570 ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(1 << index)));
4571 }
4572 ++index;
4573 input_value >>= 1;
4574 }
4575 if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(0)));
4576 return ret;
4577 }
4578
string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)4579 static inline const char* string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)
4580 {
4581 switch ((VkExternalFenceFeatureFlagBitsKHR)input_value)
4582 {
4583 case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
4584 return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
4585 case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
4586 return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
4587 default:
4588 return "Unhandled VkExternalFenceFeatureFlagBitsKHR";
4589 }
4590 }
4591
string_VkExternalFenceFeatureFlagsKHR(VkExternalFenceFeatureFlagsKHR input_value)4592 static inline std::string string_VkExternalFenceFeatureFlagsKHR(VkExternalFenceFeatureFlagsKHR input_value)
4593 {
4594 std::string ret;
4595 int index = 0;
4596 while(input_value) {
4597 if (input_value & 1) {
4598 if( !ret.empty()) ret.append("|");
4599 ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(1 << index)));
4600 }
4601 ++index;
4602 input_value >>= 1;
4603 }
4604 if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(0)));
4605 return ret;
4606 }
4607
string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)4608 static inline const char* string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)
4609 {
4610 switch ((VkFenceImportFlagBitsKHR)input_value)
4611 {
4612 case VK_FENCE_IMPORT_TEMPORARY_BIT:
4613 return "VK_FENCE_IMPORT_TEMPORARY_BIT";
4614 default:
4615 return "Unhandled VkFenceImportFlagBitsKHR";
4616 }
4617 }
4618
string_VkFenceImportFlagsKHR(VkFenceImportFlagsKHR input_value)4619 static inline std::string string_VkFenceImportFlagsKHR(VkFenceImportFlagsKHR input_value)
4620 {
4621 std::string ret;
4622 int index = 0;
4623 while(input_value) {
4624 if (input_value & 1) {
4625 if( !ret.empty()) ret.append("|");
4626 ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(1 << index)));
4627 }
4628 ++index;
4629 input_value >>= 1;
4630 }
4631 if( ret.empty()) ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(0)));
4632 return ret;
4633 }
4634
string_VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR input_value)4635 static inline const char* string_VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR input_value)
4636 {
4637 switch ((VkPointClippingBehaviorKHR)input_value)
4638 {
4639 case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
4640 return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
4641 case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
4642 return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
4643 default:
4644 return "Unhandled VkPointClippingBehaviorKHR";
4645 }
4646 }
4647
string_VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR input_value)4648 static inline const char* string_VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR input_value)
4649 {
4650 switch ((VkTessellationDomainOriginKHR)input_value)
4651 {
4652 case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
4653 return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
4654 case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
4655 return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
4656 default:
4657 return "Unhandled VkTessellationDomainOriginKHR";
4658 }
4659 }
4660
string_VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR input_value)4661 static inline const char* string_VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR input_value)
4662 {
4663 switch ((VkSamplerYcbcrModelConversionKHR)input_value)
4664 {
4665 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
4666 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
4667 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
4668 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
4669 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
4670 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
4671 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
4672 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
4673 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
4674 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
4675 default:
4676 return "Unhandled VkSamplerYcbcrModelConversionKHR";
4677 }
4678 }
4679
string_VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR input_value)4680 static inline const char* string_VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR input_value)
4681 {
4682 switch ((VkSamplerYcbcrRangeKHR)input_value)
4683 {
4684 case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
4685 return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
4686 case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
4687 return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
4688 default:
4689 return "Unhandled VkSamplerYcbcrRangeKHR";
4690 }
4691 }
4692
string_VkChromaLocationKHR(VkChromaLocationKHR input_value)4693 static inline const char* string_VkChromaLocationKHR(VkChromaLocationKHR input_value)
4694 {
4695 switch ((VkChromaLocationKHR)input_value)
4696 {
4697 case VK_CHROMA_LOCATION_COSITED_EVEN:
4698 return "VK_CHROMA_LOCATION_COSITED_EVEN";
4699 case VK_CHROMA_LOCATION_MIDPOINT:
4700 return "VK_CHROMA_LOCATION_MIDPOINT";
4701 default:
4702 return "Unhandled VkChromaLocationKHR";
4703 }
4704 }
4705
string_VkDriverIdKHR(VkDriverIdKHR input_value)4706 static inline const char* string_VkDriverIdKHR(VkDriverIdKHR input_value)
4707 {
4708 switch ((VkDriverIdKHR)input_value)
4709 {
4710 case VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR:
4711 return "VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR";
4712 case VK_DRIVER_ID_AMD_PROPRIETARY_KHR:
4713 return "VK_DRIVER_ID_AMD_PROPRIETARY_KHR";
4714 case VK_DRIVER_ID_ARM_PROPRIETARY_KHR:
4715 return "VK_DRIVER_ID_ARM_PROPRIETARY_KHR";
4716 case VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR:
4717 return "VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR";
4718 case VK_DRIVER_ID_GGP_PROPRIETARY_KHR:
4719 return "VK_DRIVER_ID_GGP_PROPRIETARY_KHR";
4720 case VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR:
4721 return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR";
4722 case VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR:
4723 return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR";
4724 case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR:
4725 return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR";
4726 case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR:
4727 return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR";
4728 case VK_DRIVER_ID_MESA_RADV_KHR:
4729 return "VK_DRIVER_ID_MESA_RADV_KHR";
4730 case VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR:
4731 return "VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR";
4732 case VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR:
4733 return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR";
4734 default:
4735 return "Unhandled VkDriverIdKHR";
4736 }
4737 }
4738
string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)4739 static inline const char* string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)
4740 {
4741 switch ((VkShaderFloatControlsIndependenceKHR)input_value)
4742 {
4743 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
4744 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR";
4745 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
4746 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR";
4747 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
4748 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR";
4749 default:
4750 return "Unhandled VkShaderFloatControlsIndependenceKHR";
4751 }
4752 }
4753
string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)4754 static inline const char* string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)
4755 {
4756 switch ((VkResolveModeFlagBitsKHR)input_value)
4757 {
4758 case VK_RESOLVE_MODE_AVERAGE_BIT_KHR:
4759 return "VK_RESOLVE_MODE_AVERAGE_BIT_KHR";
4760 case VK_RESOLVE_MODE_MAX_BIT_KHR:
4761 return "VK_RESOLVE_MODE_MAX_BIT_KHR";
4762 case VK_RESOLVE_MODE_MIN_BIT_KHR:
4763 return "VK_RESOLVE_MODE_MIN_BIT_KHR";
4764 case VK_RESOLVE_MODE_NONE_KHR:
4765 return "VK_RESOLVE_MODE_NONE_KHR";
4766 case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR:
4767 return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR";
4768 default:
4769 return "Unhandled VkResolveModeFlagBitsKHR";
4770 }
4771 }
4772
string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR input_value)4773 static inline std::string string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR input_value)
4774 {
4775 std::string ret;
4776 int index = 0;
4777 while(input_value) {
4778 if (input_value & 1) {
4779 if( !ret.empty()) ret.append("|");
4780 ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(1 << index)));
4781 }
4782 ++index;
4783 input_value >>= 1;
4784 }
4785 if( ret.empty()) ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(0)));
4786 return ret;
4787 }
4788
string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)4789 static inline const char* string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)
4790 {
4791 switch ((VkPipelineExecutableStatisticFormatKHR)input_value)
4792 {
4793 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
4794 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR";
4795 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
4796 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR";
4797 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
4798 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR";
4799 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
4800 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR";
4801 default:
4802 return "Unhandled VkPipelineExecutableStatisticFormatKHR";
4803 }
4804 }
4805
string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)4806 static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)
4807 {
4808 switch ((VkDebugReportObjectTypeEXT)input_value)
4809 {
4810 case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT:
4811 return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT";
4812 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
4813 return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
4814 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
4815 return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
4816 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
4817 return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
4818 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
4819 return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
4820 case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT:
4821 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT";
4822 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
4823 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
4824 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
4825 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
4826 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
4827 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
4828 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT:
4829 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT";
4830 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
4831 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
4832 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
4833 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
4834 case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:
4835 return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
4836 case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:
4837 return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
4838 case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
4839 return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
4840 case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
4841 return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
4842 case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
4843 return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
4844 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
4845 return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
4846 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
4847 return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
4848 case VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT:
4849 return "VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT";
4850 case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
4851 return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
4852 case VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT:
4853 return "VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT";
4854 case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
4855 return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
4856 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
4857 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
4858 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
4859 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
4860 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
4861 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
4862 case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
4863 return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
4864 case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
4865 return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
4866 case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
4867 return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
4868 case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
4869 return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
4870 case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT:
4871 return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT";
4872 case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
4873 return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
4874 case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
4875 return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
4876 case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
4877 return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
4878 case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
4879 return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
4880 case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
4881 return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
4882 case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT:
4883 return "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT";
4884 default:
4885 return "Unhandled VkDebugReportObjectTypeEXT";
4886 }
4887 }
4888
string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)4889 static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)
4890 {
4891 switch ((VkDebugReportFlagBitsEXT)input_value)
4892 {
4893 case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
4894 return "VK_DEBUG_REPORT_DEBUG_BIT_EXT";
4895 case VK_DEBUG_REPORT_ERROR_BIT_EXT:
4896 return "VK_DEBUG_REPORT_ERROR_BIT_EXT";
4897 case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
4898 return "VK_DEBUG_REPORT_INFORMATION_BIT_EXT";
4899 case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
4900 return "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT";
4901 case VK_DEBUG_REPORT_WARNING_BIT_EXT:
4902 return "VK_DEBUG_REPORT_WARNING_BIT_EXT";
4903 default:
4904 return "Unhandled VkDebugReportFlagBitsEXT";
4905 }
4906 }
4907
string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value)4908 static inline std::string string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value)
4909 {
4910 std::string ret;
4911 int index = 0;
4912 while(input_value) {
4913 if (input_value & 1) {
4914 if( !ret.empty()) ret.append("|");
4915 ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(1 << index)));
4916 }
4917 ++index;
4918 input_value >>= 1;
4919 }
4920 if( ret.empty()) ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(0)));
4921 return ret;
4922 }
4923
string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)4924 static inline const char* string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)
4925 {
4926 switch ((VkRasterizationOrderAMD)input_value)
4927 {
4928 case VK_RASTERIZATION_ORDER_RELAXED_AMD:
4929 return "VK_RASTERIZATION_ORDER_RELAXED_AMD";
4930 case VK_RASTERIZATION_ORDER_STRICT_AMD:
4931 return "VK_RASTERIZATION_ORDER_STRICT_AMD";
4932 default:
4933 return "Unhandled VkRasterizationOrderAMD";
4934 }
4935 }
4936
string_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD input_value)4937 static inline const char* string_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD input_value)
4938 {
4939 switch ((VkShaderInfoTypeAMD)input_value)
4940 {
4941 case VK_SHADER_INFO_TYPE_BINARY_AMD:
4942 return "VK_SHADER_INFO_TYPE_BINARY_AMD";
4943 case VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD:
4944 return "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD";
4945 case VK_SHADER_INFO_TYPE_STATISTICS_AMD:
4946 return "VK_SHADER_INFO_TYPE_STATISTICS_AMD";
4947 default:
4948 return "Unhandled VkShaderInfoTypeAMD";
4949 }
4950 }
4951
string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)4952 static inline const char* string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)
4953 {
4954 switch ((VkExternalMemoryHandleTypeFlagBitsNV)input_value)
4955 {
4956 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV:
4957 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV";
4958 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV:
4959 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV";
4960 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV:
4961 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV";
4962 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV:
4963 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV";
4964 default:
4965 return "Unhandled VkExternalMemoryHandleTypeFlagBitsNV";
4966 }
4967 }
4968
string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value)4969 static inline std::string string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value)
4970 {
4971 std::string ret;
4972 int index = 0;
4973 while(input_value) {
4974 if (input_value & 1) {
4975 if( !ret.empty()) ret.append("|");
4976 ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(1 << index)));
4977 }
4978 ++index;
4979 input_value >>= 1;
4980 }
4981 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(0)));
4982 return ret;
4983 }
4984
string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)4985 static inline const char* string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)
4986 {
4987 switch ((VkExternalMemoryFeatureFlagBitsNV)input_value)
4988 {
4989 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV:
4990 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV";
4991 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV:
4992 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV";
4993 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV:
4994 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV";
4995 default:
4996 return "Unhandled VkExternalMemoryFeatureFlagBitsNV";
4997 }
4998 }
4999
string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value)5000 static inline std::string string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value)
5001 {
5002 std::string ret;
5003 int index = 0;
5004 while(input_value) {
5005 if (input_value & 1) {
5006 if( !ret.empty()) ret.append("|");
5007 ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(1 << index)));
5008 }
5009 ++index;
5010 input_value >>= 1;
5011 }
5012 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(0)));
5013 return ret;
5014 }
5015
string_VkValidationCheckEXT(VkValidationCheckEXT input_value)5016 static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input_value)
5017 {
5018 switch ((VkValidationCheckEXT)input_value)
5019 {
5020 case VK_VALIDATION_CHECK_ALL_EXT:
5021 return "VK_VALIDATION_CHECK_ALL_EXT";
5022 case VK_VALIDATION_CHECK_SHADERS_EXT:
5023 return "VK_VALIDATION_CHECK_SHADERS_EXT";
5024 default:
5025 return "Unhandled VkValidationCheckEXT";
5026 }
5027 }
5028
string_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT input_value)5029 static inline const char* string_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT input_value)
5030 {
5031 switch ((VkConditionalRenderingFlagBitsEXT)input_value)
5032 {
5033 case VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT:
5034 return "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT";
5035 default:
5036 return "Unhandled VkConditionalRenderingFlagBitsEXT";
5037 }
5038 }
5039
string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value)5040 static inline std::string string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value)
5041 {
5042 std::string ret;
5043 int index = 0;
5044 while(input_value) {
5045 if (input_value & 1) {
5046 if( !ret.empty()) ret.append("|");
5047 ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(1 << index)));
5048 }
5049 ++index;
5050 input_value >>= 1;
5051 }
5052 if( ret.empty()) ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(0)));
5053 return ret;
5054 }
5055
string_VkIndirectCommandsLayoutUsageFlagBitsNVX(VkIndirectCommandsLayoutUsageFlagBitsNVX input_value)5056 static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsNVX(VkIndirectCommandsLayoutUsageFlagBitsNVX input_value)
5057 {
5058 switch ((VkIndirectCommandsLayoutUsageFlagBitsNVX)input_value)
5059 {
5060 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX:
5061 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX";
5062 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX:
5063 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX";
5064 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX:
5065 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX";
5066 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX:
5067 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX";
5068 default:
5069 return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsNVX";
5070 }
5071 }
5072
string_VkIndirectCommandsLayoutUsageFlagsNVX(VkIndirectCommandsLayoutUsageFlagsNVX input_value)5073 static inline std::string string_VkIndirectCommandsLayoutUsageFlagsNVX(VkIndirectCommandsLayoutUsageFlagsNVX input_value)
5074 {
5075 std::string ret;
5076 int index = 0;
5077 while(input_value) {
5078 if (input_value & 1) {
5079 if( !ret.empty()) ret.append("|");
5080 ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNVX(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNVX>(1 << index)));
5081 }
5082 ++index;
5083 input_value >>= 1;
5084 }
5085 if( ret.empty()) ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNVX(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNVX>(0)));
5086 return ret;
5087 }
5088
string_VkObjectEntryUsageFlagBitsNVX(VkObjectEntryUsageFlagBitsNVX input_value)5089 static inline const char* string_VkObjectEntryUsageFlagBitsNVX(VkObjectEntryUsageFlagBitsNVX input_value)
5090 {
5091 switch ((VkObjectEntryUsageFlagBitsNVX)input_value)
5092 {
5093 case VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX:
5094 return "VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX";
5095 case VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX:
5096 return "VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX";
5097 default:
5098 return "Unhandled VkObjectEntryUsageFlagBitsNVX";
5099 }
5100 }
5101
string_VkObjectEntryUsageFlagsNVX(VkObjectEntryUsageFlagsNVX input_value)5102 static inline std::string string_VkObjectEntryUsageFlagsNVX(VkObjectEntryUsageFlagsNVX input_value)
5103 {
5104 std::string ret;
5105 int index = 0;
5106 while(input_value) {
5107 if (input_value & 1) {
5108 if( !ret.empty()) ret.append("|");
5109 ret.append(string_VkObjectEntryUsageFlagBitsNVX(static_cast<VkObjectEntryUsageFlagBitsNVX>(1 << index)));
5110 }
5111 ++index;
5112 input_value >>= 1;
5113 }
5114 if( ret.empty()) ret.append(string_VkObjectEntryUsageFlagBitsNVX(static_cast<VkObjectEntryUsageFlagBitsNVX>(0)));
5115 return ret;
5116 }
5117
string_VkIndirectCommandsTokenTypeNVX(VkIndirectCommandsTokenTypeNVX input_value)5118 static inline const char* string_VkIndirectCommandsTokenTypeNVX(VkIndirectCommandsTokenTypeNVX input_value)
5119 {
5120 switch ((VkIndirectCommandsTokenTypeNVX)input_value)
5121 {
5122 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX:
5123 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX";
5124 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX:
5125 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX";
5126 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX:
5127 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX";
5128 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX:
5129 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX";
5130 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX:
5131 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX";
5132 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX:
5133 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX";
5134 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX:
5135 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX";
5136 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX:
5137 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX";
5138 default:
5139 return "Unhandled VkIndirectCommandsTokenTypeNVX";
5140 }
5141 }
5142
string_VkObjectEntryTypeNVX(VkObjectEntryTypeNVX input_value)5143 static inline const char* string_VkObjectEntryTypeNVX(VkObjectEntryTypeNVX input_value)
5144 {
5145 switch ((VkObjectEntryTypeNVX)input_value)
5146 {
5147 case VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX:
5148 return "VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX";
5149 case VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX:
5150 return "VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX";
5151 case VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX:
5152 return "VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX";
5153 case VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX:
5154 return "VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX";
5155 case VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX:
5156 return "VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX";
5157 default:
5158 return "Unhandled VkObjectEntryTypeNVX";
5159 }
5160 }
5161
string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)5162 static inline const char* string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)
5163 {
5164 switch ((VkSurfaceCounterFlagBitsEXT)input_value)
5165 {
5166 case VK_SURFACE_COUNTER_VBLANK_EXT:
5167 return "VK_SURFACE_COUNTER_VBLANK_EXT";
5168 default:
5169 return "Unhandled VkSurfaceCounterFlagBitsEXT";
5170 }
5171 }
5172
string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value)5173 static inline std::string string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value)
5174 {
5175 std::string ret;
5176 int index = 0;
5177 while(input_value) {
5178 if (input_value & 1) {
5179 if( !ret.empty()) ret.append("|");
5180 ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(1 << index)));
5181 }
5182 ++index;
5183 input_value >>= 1;
5184 }
5185 if( ret.empty()) ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(0)));
5186 return ret;
5187 }
5188
string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)5189 static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)
5190 {
5191 switch ((VkDisplayPowerStateEXT)input_value)
5192 {
5193 case VK_DISPLAY_POWER_STATE_OFF_EXT:
5194 return "VK_DISPLAY_POWER_STATE_OFF_EXT";
5195 case VK_DISPLAY_POWER_STATE_ON_EXT:
5196 return "VK_DISPLAY_POWER_STATE_ON_EXT";
5197 case VK_DISPLAY_POWER_STATE_SUSPEND_EXT:
5198 return "VK_DISPLAY_POWER_STATE_SUSPEND_EXT";
5199 default:
5200 return "Unhandled VkDisplayPowerStateEXT";
5201 }
5202 }
5203
string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)5204 static inline const char* string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)
5205 {
5206 switch ((VkDeviceEventTypeEXT)input_value)
5207 {
5208 case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT:
5209 return "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT";
5210 default:
5211 return "Unhandled VkDeviceEventTypeEXT";
5212 }
5213 }
5214
string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)5215 static inline const char* string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)
5216 {
5217 switch ((VkDisplayEventTypeEXT)input_value)
5218 {
5219 case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT:
5220 return "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT";
5221 default:
5222 return "Unhandled VkDisplayEventTypeEXT";
5223 }
5224 }
5225
string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)5226 static inline const char* string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)
5227 {
5228 switch ((VkViewportCoordinateSwizzleNV)input_value)
5229 {
5230 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV:
5231 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV";
5232 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV:
5233 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV";
5234 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV:
5235 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV";
5236 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV:
5237 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV";
5238 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV:
5239 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV";
5240 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV:
5241 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV";
5242 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV:
5243 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV";
5244 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV:
5245 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV";
5246 default:
5247 return "Unhandled VkViewportCoordinateSwizzleNV";
5248 }
5249 }
5250
string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)5251 static inline const char* string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)
5252 {
5253 switch ((VkDiscardRectangleModeEXT)input_value)
5254 {
5255 case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT:
5256 return "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT";
5257 case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT:
5258 return "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT";
5259 default:
5260 return "Unhandled VkDiscardRectangleModeEXT";
5261 }
5262 }
5263
string_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT input_value)5264 static inline const char* string_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT input_value)
5265 {
5266 switch ((VkConservativeRasterizationModeEXT)input_value)
5267 {
5268 case VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT:
5269 return "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT";
5270 case VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT:
5271 return "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT";
5272 case VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT:
5273 return "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT";
5274 default:
5275 return "Unhandled VkConservativeRasterizationModeEXT";
5276 }
5277 }
5278
string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT input_value)5279 static inline const char* string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT input_value)
5280 {
5281 switch ((VkDebugUtilsMessageSeverityFlagBitsEXT)input_value)
5282 {
5283 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
5284 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT";
5285 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
5286 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT";
5287 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
5288 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT";
5289 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
5290 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT";
5291 default:
5292 return "Unhandled VkDebugUtilsMessageSeverityFlagBitsEXT";
5293 }
5294 }
5295
string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value)5296 static inline std::string string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value)
5297 {
5298 std::string ret;
5299 int index = 0;
5300 while(input_value) {
5301 if (input_value & 1) {
5302 if( !ret.empty()) ret.append("|");
5303 ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(1 << index)));
5304 }
5305 ++index;
5306 input_value >>= 1;
5307 }
5308 if( ret.empty()) ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(0)));
5309 return ret;
5310 }
5311
string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT input_value)5312 static inline const char* string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT input_value)
5313 {
5314 switch ((VkDebugUtilsMessageTypeFlagBitsEXT)input_value)
5315 {
5316 case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
5317 return "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT";
5318 case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
5319 return "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT";
5320 case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
5321 return "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT";
5322 default:
5323 return "Unhandled VkDebugUtilsMessageTypeFlagBitsEXT";
5324 }
5325 }
5326
string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value)5327 static inline std::string string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value)
5328 {
5329 std::string ret;
5330 int index = 0;
5331 while(input_value) {
5332 if (input_value & 1) {
5333 if( !ret.empty()) ret.append("|");
5334 ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(1 << index)));
5335 }
5336 ++index;
5337 input_value >>= 1;
5338 }
5339 if( ret.empty()) ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(0)));
5340 return ret;
5341 }
5342
string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)5343 static inline const char* string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)
5344 {
5345 switch ((VkSamplerReductionModeEXT)input_value)
5346 {
5347 case VK_SAMPLER_REDUCTION_MODE_MAX_EXT:
5348 return "VK_SAMPLER_REDUCTION_MODE_MAX_EXT";
5349 case VK_SAMPLER_REDUCTION_MODE_MIN_EXT:
5350 return "VK_SAMPLER_REDUCTION_MODE_MIN_EXT";
5351 case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT:
5352 return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT";
5353 default:
5354 return "Unhandled VkSamplerReductionModeEXT";
5355 }
5356 }
5357
string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)5358 static inline const char* string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)
5359 {
5360 switch ((VkBlendOverlapEXT)input_value)
5361 {
5362 case VK_BLEND_OVERLAP_CONJOINT_EXT:
5363 return "VK_BLEND_OVERLAP_CONJOINT_EXT";
5364 case VK_BLEND_OVERLAP_DISJOINT_EXT:
5365 return "VK_BLEND_OVERLAP_DISJOINT_EXT";
5366 case VK_BLEND_OVERLAP_UNCORRELATED_EXT:
5367 return "VK_BLEND_OVERLAP_UNCORRELATED_EXT";
5368 default:
5369 return "Unhandled VkBlendOverlapEXT";
5370 }
5371 }
5372
string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)5373 static inline const char* string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)
5374 {
5375 switch ((VkCoverageModulationModeNV)input_value)
5376 {
5377 case VK_COVERAGE_MODULATION_MODE_ALPHA_NV:
5378 return "VK_COVERAGE_MODULATION_MODE_ALPHA_NV";
5379 case VK_COVERAGE_MODULATION_MODE_NONE_NV:
5380 return "VK_COVERAGE_MODULATION_MODE_NONE_NV";
5381 case VK_COVERAGE_MODULATION_MODE_RGBA_NV:
5382 return "VK_COVERAGE_MODULATION_MODE_RGBA_NV";
5383 case VK_COVERAGE_MODULATION_MODE_RGB_NV:
5384 return "VK_COVERAGE_MODULATION_MODE_RGB_NV";
5385 default:
5386 return "Unhandled VkCoverageModulationModeNV";
5387 }
5388 }
5389
string_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT input_value)5390 static inline const char* string_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT input_value)
5391 {
5392 switch ((VkValidationCacheHeaderVersionEXT)input_value)
5393 {
5394 case VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT:
5395 return "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT";
5396 default:
5397 return "Unhandled VkValidationCacheHeaderVersionEXT";
5398 }
5399 }
5400
string_VkDescriptorBindingFlagBitsEXT(VkDescriptorBindingFlagBitsEXT input_value)5401 static inline const char* string_VkDescriptorBindingFlagBitsEXT(VkDescriptorBindingFlagBitsEXT input_value)
5402 {
5403 switch ((VkDescriptorBindingFlagBitsEXT)input_value)
5404 {
5405 case VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT:
5406 return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT";
5407 case VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT:
5408 return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT";
5409 case VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT:
5410 return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT";
5411 case VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT:
5412 return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT";
5413 default:
5414 return "Unhandled VkDescriptorBindingFlagBitsEXT";
5415 }
5416 }
5417
string_VkDescriptorBindingFlagsEXT(VkDescriptorBindingFlagsEXT input_value)5418 static inline std::string string_VkDescriptorBindingFlagsEXT(VkDescriptorBindingFlagsEXT input_value)
5419 {
5420 std::string ret;
5421 int index = 0;
5422 while(input_value) {
5423 if (input_value & 1) {
5424 if( !ret.empty()) ret.append("|");
5425 ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(1 << index)));
5426 }
5427 ++index;
5428 input_value >>= 1;
5429 }
5430 if( ret.empty()) ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(0)));
5431 return ret;
5432 }
5433
string_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV input_value)5434 static inline const char* string_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV input_value)
5435 {
5436 switch ((VkShadingRatePaletteEntryNV)input_value)
5437 {
5438 case VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV:
5439 return "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV";
5440 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV:
5441 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV";
5442 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV:
5443 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV";
5444 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV:
5445 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV";
5446 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV:
5447 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV";
5448 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV:
5449 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV";
5450 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV:
5451 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV";
5452 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV:
5453 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV";
5454 case VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV:
5455 return "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV";
5456 case VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV:
5457 return "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV";
5458 case VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV:
5459 return "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV";
5460 case VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV:
5461 return "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV";
5462 default:
5463 return "Unhandled VkShadingRatePaletteEntryNV";
5464 }
5465 }
5466
string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV input_value)5467 static inline const char* string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV input_value)
5468 {
5469 switch ((VkCoarseSampleOrderTypeNV)input_value)
5470 {
5471 case VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV:
5472 return "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV";
5473 case VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV:
5474 return "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV";
5475 case VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV:
5476 return "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV";
5477 case VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV:
5478 return "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV";
5479 default:
5480 return "Unhandled VkCoarseSampleOrderTypeNV";
5481 }
5482 }
5483
string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)5484 static inline const char* string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)
5485 {
5486 switch ((VkAccelerationStructureTypeNV)input_value)
5487 {
5488 case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV:
5489 return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV";
5490 case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV:
5491 return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV";
5492 default:
5493 return "Unhandled VkAccelerationStructureTypeNV";
5494 }
5495 }
5496
string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)5497 static inline const char* string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)
5498 {
5499 switch ((VkRayTracingShaderGroupTypeNV)input_value)
5500 {
5501 case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV:
5502 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV";
5503 case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV:
5504 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV";
5505 case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV:
5506 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV";
5507 default:
5508 return "Unhandled VkRayTracingShaderGroupTypeNV";
5509 }
5510 }
5511
string_VkGeometryTypeNV(VkGeometryTypeNV input_value)5512 static inline const char* string_VkGeometryTypeNV(VkGeometryTypeNV input_value)
5513 {
5514 switch ((VkGeometryTypeNV)input_value)
5515 {
5516 case VK_GEOMETRY_TYPE_AABBS_NV:
5517 return "VK_GEOMETRY_TYPE_AABBS_NV";
5518 case VK_GEOMETRY_TYPE_TRIANGLES_NV:
5519 return "VK_GEOMETRY_TYPE_TRIANGLES_NV";
5520 default:
5521 return "Unhandled VkGeometryTypeNV";
5522 }
5523 }
5524
string_VkGeometryFlagBitsNV(VkGeometryFlagBitsNV input_value)5525 static inline const char* string_VkGeometryFlagBitsNV(VkGeometryFlagBitsNV input_value)
5526 {
5527 switch ((VkGeometryFlagBitsNV)input_value)
5528 {
5529 case VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV:
5530 return "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV";
5531 case VK_GEOMETRY_OPAQUE_BIT_NV:
5532 return "VK_GEOMETRY_OPAQUE_BIT_NV";
5533 default:
5534 return "Unhandled VkGeometryFlagBitsNV";
5535 }
5536 }
5537
string_VkGeometryFlagsNV(VkGeometryFlagsNV input_value)5538 static inline std::string string_VkGeometryFlagsNV(VkGeometryFlagsNV input_value)
5539 {
5540 std::string ret;
5541 int index = 0;
5542 while(input_value) {
5543 if (input_value & 1) {
5544 if( !ret.empty()) ret.append("|");
5545 ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(1 << index)));
5546 }
5547 ++index;
5548 input_value >>= 1;
5549 }
5550 if( ret.empty()) ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(0)));
5551 return ret;
5552 }
5553
string_VkGeometryInstanceFlagBitsNV(VkGeometryInstanceFlagBitsNV input_value)5554 static inline const char* string_VkGeometryInstanceFlagBitsNV(VkGeometryInstanceFlagBitsNV input_value)
5555 {
5556 switch ((VkGeometryInstanceFlagBitsNV)input_value)
5557 {
5558 case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV:
5559 return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV";
5560 case VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV:
5561 return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV";
5562 case VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV:
5563 return "VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV";
5564 case VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV:
5565 return "VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV";
5566 default:
5567 return "Unhandled VkGeometryInstanceFlagBitsNV";
5568 }
5569 }
5570
string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFlagsNV input_value)5571 static inline std::string string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFlagsNV input_value)
5572 {
5573 std::string ret;
5574 int index = 0;
5575 while(input_value) {
5576 if (input_value & 1) {
5577 if( !ret.empty()) ret.append("|");
5578 ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(1 << index)));
5579 }
5580 ++index;
5581 input_value >>= 1;
5582 }
5583 if( ret.empty()) ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(0)));
5584 return ret;
5585 }
5586
string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)5587 static inline const char* string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)
5588 {
5589 switch ((VkBuildAccelerationStructureFlagBitsNV)input_value)
5590 {
5591 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV:
5592 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV";
5593 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV:
5594 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV";
5595 case VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV:
5596 return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV";
5597 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV:
5598 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV";
5599 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV:
5600 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV";
5601 default:
5602 return "Unhandled VkBuildAccelerationStructureFlagBitsNV";
5603 }
5604 }
5605
string_VkBuildAccelerationStructureFlagsNV(VkBuildAccelerationStructureFlagsNV input_value)5606 static inline std::string string_VkBuildAccelerationStructureFlagsNV(VkBuildAccelerationStructureFlagsNV input_value)
5607 {
5608 std::string ret;
5609 int index = 0;
5610 while(input_value) {
5611 if (input_value & 1) {
5612 if( !ret.empty()) ret.append("|");
5613 ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(1 << index)));
5614 }
5615 ++index;
5616 input_value >>= 1;
5617 }
5618 if( ret.empty()) ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(0)));
5619 return ret;
5620 }
5621
string_VkCopyAccelerationStructureModeNV(VkCopyAccelerationStructureModeNV input_value)5622 static inline const char* string_VkCopyAccelerationStructureModeNV(VkCopyAccelerationStructureModeNV input_value)
5623 {
5624 switch ((VkCopyAccelerationStructureModeNV)input_value)
5625 {
5626 case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV:
5627 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV";
5628 case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV:
5629 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV";
5630 default:
5631 return "Unhandled VkCopyAccelerationStructureModeNV";
5632 }
5633 }
5634
string_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV input_value)5635 static inline const char* string_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV input_value)
5636 {
5637 switch ((VkAccelerationStructureMemoryRequirementsTypeNV)input_value)
5638 {
5639 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV:
5640 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV";
5641 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV:
5642 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV";
5643 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV:
5644 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV";
5645 default:
5646 return "Unhandled VkAccelerationStructureMemoryRequirementsTypeNV";
5647 }
5648 }
5649
string_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT input_value)5650 static inline const char* string_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT input_value)
5651 {
5652 switch ((VkQueueGlobalPriorityEXT)input_value)
5653 {
5654 case VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT:
5655 return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT";
5656 case VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT:
5657 return "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT";
5658 case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT:
5659 return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT";
5660 case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT:
5661 return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT";
5662 default:
5663 return "Unhandled VkQueueGlobalPriorityEXT";
5664 }
5665 }
5666
string_VkTimeDomainEXT(VkTimeDomainEXT input_value)5667 static inline const char* string_VkTimeDomainEXT(VkTimeDomainEXT input_value)
5668 {
5669 switch ((VkTimeDomainEXT)input_value)
5670 {
5671 case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT:
5672 return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT";
5673 case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT:
5674 return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT";
5675 case VK_TIME_DOMAIN_DEVICE_EXT:
5676 return "VK_TIME_DOMAIN_DEVICE_EXT";
5677 case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT:
5678 return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT";
5679 default:
5680 return "Unhandled VkTimeDomainEXT";
5681 }
5682 }
5683
string_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD input_value)5684 static inline const char* string_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD input_value)
5685 {
5686 switch ((VkMemoryOverallocationBehaviorAMD)input_value)
5687 {
5688 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD:
5689 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD";
5690 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD:
5691 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD";
5692 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD:
5693 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD";
5694 default:
5695 return "Unhandled VkMemoryOverallocationBehaviorAMD";
5696 }
5697 }
5698
string_VkPipelineCreationFeedbackFlagBitsEXT(VkPipelineCreationFeedbackFlagBitsEXT input_value)5699 static inline const char* string_VkPipelineCreationFeedbackFlagBitsEXT(VkPipelineCreationFeedbackFlagBitsEXT input_value)
5700 {
5701 switch ((VkPipelineCreationFeedbackFlagBitsEXT)input_value)
5702 {
5703 case VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT:
5704 return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT";
5705 case VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT:
5706 return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT";
5707 case VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT:
5708 return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT";
5709 default:
5710 return "Unhandled VkPipelineCreationFeedbackFlagBitsEXT";
5711 }
5712 }
5713
string_VkPipelineCreationFeedbackFlagsEXT(VkPipelineCreationFeedbackFlagsEXT input_value)5714 static inline std::string string_VkPipelineCreationFeedbackFlagsEXT(VkPipelineCreationFeedbackFlagsEXT input_value)
5715 {
5716 std::string ret;
5717 int index = 0;
5718 while(input_value) {
5719 if (input_value & 1) {
5720 if( !ret.empty()) ret.append("|");
5721 ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(1 << index)));
5722 }
5723 ++index;
5724 input_value >>= 1;
5725 }
5726 if( ret.empty()) ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(0)));
5727 return ret;
5728 }
5729
string_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL input_value)5730 static inline const char* string_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL input_value)
5731 {
5732 switch ((VkPerformanceConfigurationTypeINTEL)input_value)
5733 {
5734 case VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL:
5735 return "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL";
5736 default:
5737 return "Unhandled VkPerformanceConfigurationTypeINTEL";
5738 }
5739 }
5740
string_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL input_value)5741 static inline const char* string_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL input_value)
5742 {
5743 switch ((VkQueryPoolSamplingModeINTEL)input_value)
5744 {
5745 case VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL:
5746 return "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL";
5747 default:
5748 return "Unhandled VkQueryPoolSamplingModeINTEL";
5749 }
5750 }
5751
string_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL input_value)5752 static inline const char* string_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL input_value)
5753 {
5754 switch ((VkPerformanceOverrideTypeINTEL)input_value)
5755 {
5756 case VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL:
5757 return "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL";
5758 case VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL:
5759 return "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL";
5760 default:
5761 return "Unhandled VkPerformanceOverrideTypeINTEL";
5762 }
5763 }
5764
string_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL input_value)5765 static inline const char* string_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL input_value)
5766 {
5767 switch ((VkPerformanceParameterTypeINTEL)input_value)
5768 {
5769 case VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL:
5770 return "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL";
5771 case VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL:
5772 return "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL";
5773 default:
5774 return "Unhandled VkPerformanceParameterTypeINTEL";
5775 }
5776 }
5777
string_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL input_value)5778 static inline const char* string_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL input_value)
5779 {
5780 switch ((VkPerformanceValueTypeINTEL)input_value)
5781 {
5782 case VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL:
5783 return "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL";
5784 case VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL:
5785 return "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL";
5786 case VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL:
5787 return "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL";
5788 case VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL:
5789 return "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL";
5790 case VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL:
5791 return "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL";
5792 default:
5793 return "Unhandled VkPerformanceValueTypeINTEL";
5794 }
5795 }
5796
string_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT input_value)5797 static inline const char* string_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT input_value)
5798 {
5799 switch ((VkValidationFeatureEnableEXT)input_value)
5800 {
5801 case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT:
5802 return "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT";
5803 case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT:
5804 return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT";
5805 case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT:
5806 return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT";
5807 default:
5808 return "Unhandled VkValidationFeatureEnableEXT";
5809 }
5810 }
5811
string_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT input_value)5812 static inline const char* string_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT input_value)
5813 {
5814 switch ((VkValidationFeatureDisableEXT)input_value)
5815 {
5816 case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT:
5817 return "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT";
5818 case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT:
5819 return "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT";
5820 case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT:
5821 return "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT";
5822 case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT:
5823 return "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT";
5824 case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT:
5825 return "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT";
5826 case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT:
5827 return "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT";
5828 case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT:
5829 return "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT";
5830 default:
5831 return "Unhandled VkValidationFeatureDisableEXT";
5832 }
5833 }
5834
string_VkComponentTypeNV(VkComponentTypeNV input_value)5835 static inline const char* string_VkComponentTypeNV(VkComponentTypeNV input_value)
5836 {
5837 switch ((VkComponentTypeNV)input_value)
5838 {
5839 case VK_COMPONENT_TYPE_FLOAT16_NV:
5840 return "VK_COMPONENT_TYPE_FLOAT16_NV";
5841 case VK_COMPONENT_TYPE_FLOAT32_NV:
5842 return "VK_COMPONENT_TYPE_FLOAT32_NV";
5843 case VK_COMPONENT_TYPE_FLOAT64_NV:
5844 return "VK_COMPONENT_TYPE_FLOAT64_NV";
5845 case VK_COMPONENT_TYPE_SINT16_NV:
5846 return "VK_COMPONENT_TYPE_SINT16_NV";
5847 case VK_COMPONENT_TYPE_SINT32_NV:
5848 return "VK_COMPONENT_TYPE_SINT32_NV";
5849 case VK_COMPONENT_TYPE_SINT64_NV:
5850 return "VK_COMPONENT_TYPE_SINT64_NV";
5851 case VK_COMPONENT_TYPE_SINT8_NV:
5852 return "VK_COMPONENT_TYPE_SINT8_NV";
5853 case VK_COMPONENT_TYPE_UINT16_NV:
5854 return "VK_COMPONENT_TYPE_UINT16_NV";
5855 case VK_COMPONENT_TYPE_UINT32_NV:
5856 return "VK_COMPONENT_TYPE_UINT32_NV";
5857 case VK_COMPONENT_TYPE_UINT64_NV:
5858 return "VK_COMPONENT_TYPE_UINT64_NV";
5859 case VK_COMPONENT_TYPE_UINT8_NV:
5860 return "VK_COMPONENT_TYPE_UINT8_NV";
5861 default:
5862 return "Unhandled VkComponentTypeNV";
5863 }
5864 }
5865
string_VkScopeNV(VkScopeNV input_value)5866 static inline const char* string_VkScopeNV(VkScopeNV input_value)
5867 {
5868 switch ((VkScopeNV)input_value)
5869 {
5870 case VK_SCOPE_DEVICE_NV:
5871 return "VK_SCOPE_DEVICE_NV";
5872 case VK_SCOPE_QUEUE_FAMILY_NV:
5873 return "VK_SCOPE_QUEUE_FAMILY_NV";
5874 case VK_SCOPE_SUBGROUP_NV:
5875 return "VK_SCOPE_SUBGROUP_NV";
5876 case VK_SCOPE_WORKGROUP_NV:
5877 return "VK_SCOPE_WORKGROUP_NV";
5878 default:
5879 return "Unhandled VkScopeNV";
5880 }
5881 }
5882
string_VkCoverageReductionModeNV(VkCoverageReductionModeNV input_value)5883 static inline const char* string_VkCoverageReductionModeNV(VkCoverageReductionModeNV input_value)
5884 {
5885 switch ((VkCoverageReductionModeNV)input_value)
5886 {
5887 case VK_COVERAGE_REDUCTION_MODE_MERGE_NV:
5888 return "VK_COVERAGE_REDUCTION_MODE_MERGE_NV";
5889 case VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV:
5890 return "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV";
5891 default:
5892 return "Unhandled VkCoverageReductionModeNV";
5893 }
5894 }
5895
5896
5897 #ifdef VK_USE_PLATFORM_WIN32_KHR
5898
string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT input_value)5899 static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT input_value)
5900 {
5901 switch ((VkFullScreenExclusiveEXT)input_value)
5902 {
5903 case VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT:
5904 return "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT";
5905 case VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT:
5906 return "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT";
5907 case VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT:
5908 return "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT";
5909 case VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT:
5910 return "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT";
5911 default:
5912 return "Unhandled VkFullScreenExclusiveEXT";
5913 }
5914 }
5915 #endif // VK_USE_PLATFORM_WIN32_KHR
5916
string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)5917 static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)
5918 {
5919 switch ((VkLineRasterizationModeEXT)input_value)
5920 {
5921 case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
5922 return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
5923 case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
5924 return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
5925 case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
5926 return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
5927 case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
5928 return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
5929 default:
5930 return "Unhandled VkLineRasterizationModeEXT";
5931 }
5932 }
5933
GetPhysDevFeatureString(uint32_t index)5934 static inline const char * GetPhysDevFeatureString(uint32_t index) {
5935 const char * IndexToPhysDevFeatureString[] = {
5936 "robustBufferAccess",
5937 "fullDrawIndexUint32",
5938 "imageCubeArray",
5939 "independentBlend",
5940 "geometryShader",
5941 "tessellationShader",
5942 "sampleRateShading",
5943 "dualSrcBlend",
5944 "logicOp",
5945 "multiDrawIndirect",
5946 "drawIndirectFirstInstance",
5947 "depthClamp",
5948 "depthBiasClamp",
5949 "fillModeNonSolid",
5950 "depthBounds",
5951 "wideLines",
5952 "largePoints",
5953 "alphaToOne",
5954 "multiViewport",
5955 "samplerAnisotropy",
5956 "textureCompressionETC2",
5957 "textureCompressionASTC_LDR",
5958 "textureCompressionBC",
5959 "occlusionQueryPrecise",
5960 "pipelineStatisticsQuery",
5961 "vertexPipelineStoresAndAtomics",
5962 "fragmentStoresAndAtomics",
5963 "shaderTessellationAndGeometryPointSize",
5964 "shaderImageGatherExtended",
5965 "shaderStorageImageExtendedFormats",
5966 "shaderStorageImageMultisample",
5967 "shaderStorageImageReadWithoutFormat",
5968 "shaderStorageImageWriteWithoutFormat",
5969 "shaderUniformBufferArrayDynamicIndexing",
5970 "shaderSampledImageArrayDynamicIndexing",
5971 "shaderStorageBufferArrayDynamicIndexing",
5972 "shaderStorageImageArrayDynamicIndexing",
5973 "shaderClipDistance",
5974 "shaderCullDistance",
5975 "shaderFloat64",
5976 "shaderInt64",
5977 "shaderInt16",
5978 "shaderResourceResidency",
5979 "shaderResourceMinLod",
5980 "sparseBinding",
5981 "sparseResidencyBuffer",
5982 "sparseResidencyImage2D",
5983 "sparseResidencyImage3D",
5984 "sparseResidency2Samples",
5985 "sparseResidency4Samples",
5986 "sparseResidency8Samples",
5987 "sparseResidency16Samples",
5988 "sparseResidencyAliased",
5989 "variableMultisampleRate",
5990 "inheritedQueries",
5991 };
5992
5993 return IndexToPhysDevFeatureString[index];
5994 }
5995