1 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
2 // See helper_file_generator.py for modifications
3
4
5 /***************************************************************************
6 *
7 * Copyright (c) 2015-2021 The Khronos Group Inc.
8 * Copyright (c) 2015-2021 Valve Corporation
9 * Copyright (c) 2015-2021 LunarG, Inc.
10 * Copyright (c) 2015-2021 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 _MSC_VER
35 #pragma warning( disable : 4065 )
36 #endif
37
38 #include <string>
39 #include <vulkan/vulkan.h>
40
41
string_VkResult(VkResult input_value)42 static inline const char* string_VkResult(VkResult input_value)
43 {
44 switch (input_value)
45 {
46 case VK_ERROR_DEVICE_LOST:
47 return "VK_ERROR_DEVICE_LOST";
48 case VK_ERROR_EXTENSION_NOT_PRESENT:
49 return "VK_ERROR_EXTENSION_NOT_PRESENT";
50 case VK_ERROR_FEATURE_NOT_PRESENT:
51 return "VK_ERROR_FEATURE_NOT_PRESENT";
52 case VK_ERROR_FORMAT_NOT_SUPPORTED:
53 return "VK_ERROR_FORMAT_NOT_SUPPORTED";
54 case VK_ERROR_FRAGMENTATION:
55 return "VK_ERROR_FRAGMENTATION";
56 case VK_ERROR_FRAGMENTED_POOL:
57 return "VK_ERROR_FRAGMENTED_POOL";
58 case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
59 return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
60 case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
61 return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
62 case VK_ERROR_INCOMPATIBLE_DRIVER:
63 return "VK_ERROR_INCOMPATIBLE_DRIVER";
64 case VK_ERROR_INITIALIZATION_FAILED:
65 return "VK_ERROR_INITIALIZATION_FAILED";
66 case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
67 return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
68 case VK_ERROR_INVALID_EXTERNAL_HANDLE:
69 return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
70 case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
71 return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
72 case VK_ERROR_INVALID_SHADER_NV:
73 return "VK_ERROR_INVALID_SHADER_NV";
74 case VK_ERROR_LAYER_NOT_PRESENT:
75 return "VK_ERROR_LAYER_NOT_PRESENT";
76 case VK_ERROR_MEMORY_MAP_FAILED:
77 return "VK_ERROR_MEMORY_MAP_FAILED";
78 case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
79 return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
80 case VK_ERROR_NOT_PERMITTED_EXT:
81 return "VK_ERROR_NOT_PERMITTED_EXT";
82 case VK_ERROR_OUT_OF_DATE_KHR:
83 return "VK_ERROR_OUT_OF_DATE_KHR";
84 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
85 return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
86 case VK_ERROR_OUT_OF_HOST_MEMORY:
87 return "VK_ERROR_OUT_OF_HOST_MEMORY";
88 case VK_ERROR_OUT_OF_POOL_MEMORY:
89 return "VK_ERROR_OUT_OF_POOL_MEMORY";
90 case VK_ERROR_SURFACE_LOST_KHR:
91 return "VK_ERROR_SURFACE_LOST_KHR";
92 case VK_ERROR_TOO_MANY_OBJECTS:
93 return "VK_ERROR_TOO_MANY_OBJECTS";
94 case VK_ERROR_UNKNOWN:
95 return "VK_ERROR_UNKNOWN";
96 case VK_ERROR_VALIDATION_FAILED_EXT:
97 return "VK_ERROR_VALIDATION_FAILED_EXT";
98 case VK_EVENT_RESET:
99 return "VK_EVENT_RESET";
100 case VK_EVENT_SET:
101 return "VK_EVENT_SET";
102 case VK_INCOMPLETE:
103 return "VK_INCOMPLETE";
104 case VK_NOT_READY:
105 return "VK_NOT_READY";
106 case VK_OPERATION_DEFERRED_KHR:
107 return "VK_OPERATION_DEFERRED_KHR";
108 case VK_OPERATION_NOT_DEFERRED_KHR:
109 return "VK_OPERATION_NOT_DEFERRED_KHR";
110 case VK_PIPELINE_COMPILE_REQUIRED_EXT:
111 return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
112 case VK_SUBOPTIMAL_KHR:
113 return "VK_SUBOPTIMAL_KHR";
114 case VK_SUCCESS:
115 return "VK_SUCCESS";
116 case VK_THREAD_DONE_KHR:
117 return "VK_THREAD_DONE_KHR";
118 case VK_THREAD_IDLE_KHR:
119 return "VK_THREAD_IDLE_KHR";
120 case VK_TIMEOUT:
121 return "VK_TIMEOUT";
122 default:
123 return "Unhandled VkResult";
124 }
125 }
126
string_VkStructureType(VkStructureType input_value)127 static inline const char* string_VkStructureType(VkStructureType input_value)
128 {
129 switch (input_value)
130 {
131 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
132 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR";
133 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
134 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR";
135 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
136 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR";
137 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
138 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV";
139 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
140 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR";
141 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
142 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR";
143 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
144 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR";
145 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
146 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR";
147 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
148 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV";
149 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
150 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR";
151 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
152 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV";
153 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
154 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV";
155 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
156 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV";
157 case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
158 return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR";
159 case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
160 return "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR";
161 case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
162 return "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR";
163 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
164 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID";
165 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
166 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID";
167 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
168 return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID";
169 case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
170 return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
171 case VK_STRUCTURE_TYPE_APPLICATION_INFO:
172 return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
173 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
174 return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2";
175 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
176 return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT";
177 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
178 return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2";
179 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
180 return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT";
181 case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
182 return "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV";
183 case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
184 return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO";
185 case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
186 return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO";
187 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
188 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO";
189 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
190 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO";
191 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
192 return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR";
193 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
194 return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO";
195 case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
196 return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
197 case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR:
198 return "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR";
199 case VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR:
200 return "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR";
201 case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
202 return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
203 case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
204 return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT";
205 case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
206 return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO";
207 case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR:
208 return "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR";
209 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
210 return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
211 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR:
212 return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR";
213 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
214 return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2";
215 case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
216 return "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO";
217 case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
218 return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
219 case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT:
220 return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT";
221 case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
222 return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV";
223 case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
224 return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV";
225 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
226 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
227 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
228 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
229 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
230 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT";
231 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
232 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
233 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
234 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM";
235 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
236 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV";
237 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR:
238 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR";
239 case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
240 return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
241 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
242 return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
243 case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
244 return "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT";
245 case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
246 return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV";
247 case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
248 return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR";
249 case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
250 return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR";
251 case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR:
252 return "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR";
253 case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR:
254 return "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR";
255 case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
256 return "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM";
257 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
258 return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
259 case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR:
260 return "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR";
261 case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR:
262 return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR";
263 case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
264 return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR";
265 case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
266 return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX";
267 case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
268 return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX";
269 case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
270 return "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX";
271 case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
272 return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR";
273 case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
274 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
275 case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
276 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
277 case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
278 return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
279 case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
280 return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
281 case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
282 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT";
283 case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
284 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT";
285 case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
286 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT";
287 case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
288 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT";
289 case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
290 return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT";
291 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
292 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
293 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
294 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
295 case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
296 return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
297 case VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR:
298 return "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR";
299 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
300 return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
301 case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
302 return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT";
303 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
304 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
305 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
306 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO";
307 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
308 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
309 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
310 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT";
311 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
312 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO";
313 case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
314 return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT";
315 case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
316 return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO";
317 case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
318 return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
319 case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
320 return "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT";
321 case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
322 return "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV";
323 case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
324 return "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT";
325 case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
326 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO";
327 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
328 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO";
329 case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
330 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO";
331 case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
332 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR";
333 case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
334 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR";
335 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
336 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO";
337 case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
338 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO";
339 case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
340 return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR";
341 case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
342 return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO";
343 case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
344 return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD";
345 case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
346 return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT";
347 case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
348 return "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT";
349 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
350 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
351 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
352 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT";
353 case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
354 return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2";
355 case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
356 return "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT";
357 case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
358 return "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT";
359 case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
360 return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
361 case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
362 return "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR";
363 case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
364 return "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD";
365 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
366 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR";
367 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
368 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR";
369 case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
370 return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR";
371 case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
372 return "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT";
373 case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
374 return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
375 case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
376 return "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR";
377 case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
378 return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
379 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
380 return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT";
381 case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
382 return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
383 case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
384 return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO";
385 case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
386 return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR";
387 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
388 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO";
389 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
390 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
391 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
392 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
393 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
394 return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
395 case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
396 return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO";
397 case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
398 return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
399 case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
400 return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES";
401 case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
402 return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES";
403 case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
404 return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID";
405 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
406 return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES";
407 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
408 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO";
409 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
410 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO";
411 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
412 return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
413 case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
414 return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES";
415 case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
416 return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
417 case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
418 return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
419 case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
420 return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
421 case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
422 return "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT";
423 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
424 return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2";
425 case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
426 return "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
427 case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
428 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO";
429 case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
430 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO";
431 case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
432 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
433 case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
434 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV";
435 case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
436 return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV";
437 case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
438 return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV";
439 case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
440 return "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV";
441 case VK_STRUCTURE_TYPE_GEOMETRY_NV:
442 return "VK_STRUCTURE_TYPE_GEOMETRY_NV";
443 case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
444 return "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV";
445 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
446 return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
447 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
448 return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV";
449 case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
450 return "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV";
451 case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
452 return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT";
453 case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
454 return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
455 case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
456 return "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA";
457 case VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR:
458 return "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR";
459 case VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR:
460 return "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR";
461 case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
462 return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
463 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
464 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT";
465 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
466 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT";
467 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
468 return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT";
469 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
470 return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO";
471 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
472 return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2";
473 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
474 return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
475 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR:
476 return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR";
477 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
478 return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2";
479 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
480 return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO";
481 case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR:
482 return "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR";
483 case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
484 return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2";
485 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
486 return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO";
487 case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
488 return "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR";
489 case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
490 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX";
491 case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
492 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT";
493 case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
494 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
495 case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
496 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX";
497 case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
498 return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO";
499 case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
500 return "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
501 case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
502 return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
503 case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
504 return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR";
505 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
506 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
507 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
508 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT";
509 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
510 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
511 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
512 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
513 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
514 return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA";
515 case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
516 return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
517 case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
518 return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
519 case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
520 return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA";
521 case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
522 return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV";
523 case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
524 return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV";
525 case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
526 return "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL";
527 case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
528 return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
529 case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
530 return "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK";
531 case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
532 return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
533 case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
534 return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
535 case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
536 return "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK";
537 case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
538 return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
539 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
540 return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO";
541 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
542 return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
543 case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
544 return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
545 case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
546 return "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR";
547 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
548 return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO";
549 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
550 return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS";
551 case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
552 return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR";
553 case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
554 return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
555 case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
556 return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR";
557 case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
558 return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR";
559 case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
560 return "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
561 case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
562 return "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT";
563 case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
564 return "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO";
565 case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
566 return "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT";
567 case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
568 return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2";
569 case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
570 return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR";
571 case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
572 return "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA";
573 case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
574 return "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT";
575 case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
576 return "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT";
577 case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
578 return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE";
579 case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
580 return "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL";
581 case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
582 return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR";
583 case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
584 return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR";
585 case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
586 return "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL";
587 case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
588 return "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL";
589 case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
590 return "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR";
591 case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
592 return "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL";
593 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
594 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES";
595 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
596 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT";
597 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
598 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES";
599 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
600 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR";
601 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
602 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR";
603 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
604 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT";
605 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
606 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT";
607 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
608 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT";
609 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
610 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES";
611 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
612 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
613 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
614 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
615 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
616 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT";
617 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
618 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV";
619 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
620 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT";
621 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
622 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT";
623 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
624 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV";
625 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
626 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV";
627 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
628 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV";
629 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
630 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV";
631 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
632 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT";
633 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
634 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT";
635 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
636 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV";
637 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
638 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT";
639 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
640 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES";
641 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
642 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES";
643 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
644 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES";
645 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
646 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV";
647 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
648 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV";
649 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
650 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT";
651 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
652 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV";
653 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
654 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT";
655 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
656 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES";
657 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
658 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT";
659 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
660 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV";
661 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
662 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT";
663 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
664 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT";
665 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
666 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO";
667 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
668 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO";
669 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
670 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO";
671 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
672 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT";
673 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
674 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO";
675 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
676 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2";
677 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
678 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES";
679 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
680 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT";
681 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
682 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT";
683 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
684 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT";
685 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
686 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT";
687 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
688 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV";
689 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
690 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT";
691 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
692 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV";
693 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
694 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV";
695 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
696 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR";
697 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
698 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR";
699 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
700 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR";
701 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
702 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT";
703 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
704 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES";
705 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
706 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES";
707 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
708 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES";
709 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
710 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES";
711 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
712 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT";
713 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
714 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2";
715 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
716 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT";
717 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
718 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT";
719 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
720 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
721 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
722 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV";
723 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
724 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT";
725 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
726 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT";
727 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
728 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
729 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
730 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
731 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
732 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES";
733 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
734 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT";
735 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
736 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT";
737 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
738 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2";
739 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
740 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV";
741 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
742 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV";
743 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
744 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES";
745 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
746 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX";
747 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
748 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES";
749 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
750 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT";
751 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
752 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT";
753 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
754 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE";
755 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
756 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT";
757 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
758 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR";
759 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
760 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR";
761 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
762 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT";
763 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
764 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR";
765 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
766 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES";
767 #ifdef VK_ENABLE_BETA_EXTENSIONS
768 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
769 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR";
770 #endif // VK_ENABLE_BETA_EXTENSIONS
771 #ifdef VK_ENABLE_BETA_EXTENSIONS
772 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
773 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR";
774 #endif // VK_ENABLE_BETA_EXTENSIONS
775 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
776 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT";
777 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
778 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2";
779 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
780 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES";
781 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
782 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES";
783 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
784 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT";
785 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
786 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT";
787 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
788 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
789 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
790 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR";
791 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
792 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV";
793 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
794 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR";
795 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
796 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR";
797 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
798 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV";
799 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
800 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV";
801 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
802 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT";
803 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
804 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT";
805 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
806 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES";
807 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
808 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES";
809 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
810 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT";
811 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
812 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES";
813 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
814 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES";
815 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
816 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT";
817 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
818 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES";
819 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
820 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR";
821 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
822 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
823 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
824 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD";
825 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
826 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT";
827 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
828 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES";
829 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
830 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES";
831 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
832 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT";
833 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
834 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV";
835 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
836 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL";
837 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
838 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV";
839 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
840 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV";
841 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
842 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES";
843 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
844 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR";
845 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
846 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR";
847 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
848 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV";
849 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
850 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV";
851 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
852 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2";
853 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
854 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES";
855 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
856 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT";
857 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
858 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT";
859 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
860 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI";
861 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
862 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI";
863 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
864 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
865 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
866 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR";
867 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
868 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT";
869 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
870 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT";
871 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
872 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT";
873 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
874 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES";
875 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
876 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES";
877 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT:
878 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT";
879 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
880 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT";
881 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
882 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT";
883 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
884 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES";
885 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
886 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES";
887 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
888 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT";
889 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
890 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT";
891 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
892 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT";
893 #ifdef VK_ENABLE_BETA_EXTENSIONS
894 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
895 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR";
896 #endif // VK_ENABLE_BETA_EXTENSIONS
897 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
898 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES";
899 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
900 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES";
901 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
902 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES";
903 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
904 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES";
905 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
906 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES";
907 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
908 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR";
909 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
910 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT";
911 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
912 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT";
913 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
914 return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR";
915 case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
916 return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
917 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
918 return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT";
919 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
920 return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
921 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
922 return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT";
923 case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
924 return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD";
925 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
926 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV";
927 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
928 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV";
929 case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
930 return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV";
931 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
932 return "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT";
933 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
934 return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
935 case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
936 return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT";
937 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
938 return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
939 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
940 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR";
941 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
942 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
943 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
944 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR";
945 case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
946 return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
947 case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
948 return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV";
949 case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
950 return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR";
951 case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
952 return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR";
953 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
954 return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
955 case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
956 return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
957 case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
958 return "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR";
959 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
960 return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
961 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
962 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT";
963 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
964 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT";
965 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
966 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
967 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
968 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT";
969 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
970 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
971 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
972 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
973 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
974 return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT";
975 case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
976 return "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV";
977 case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
978 return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT";
979 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
980 return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
981 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
982 return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT";
983 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
984 return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO";
985 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
986 return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
987 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
988 return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT";
989 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
990 return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
991 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
992 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV";
993 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
994 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV";
995 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
996 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV";
997 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
998 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
999 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
1000 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV";
1001 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
1002 return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV";
1003 case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
1004 return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP";
1005 case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
1006 return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
1007 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1008 return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
1009 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
1010 return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
1011 case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT:
1012 return "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT";
1013 case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
1014 return "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO";
1015 case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
1016 return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
1017 case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
1018 return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR";
1019 case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
1020 return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL";
1021 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
1022 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV";
1023 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
1024 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV";
1025 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
1026 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT";
1027 case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
1028 return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2";
1029 case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
1030 return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR";
1031 case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
1032 return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV";
1033 case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
1034 return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR";
1035 case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
1036 return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR";
1037 case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
1038 return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV";
1039 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
1040 return "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO";
1041 case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
1042 return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
1043 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
1044 return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
1045 case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
1046 return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2";
1047 case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
1048 return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT";
1049 case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
1050 return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO";
1051 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
1052 return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO";
1053 case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
1054 return "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT";
1055 case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
1056 return "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM";
1057 case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR:
1058 return "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR";
1059 case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
1060 return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
1061 case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
1062 return "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT";
1063 case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
1064 return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO";
1065 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
1066 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO";
1067 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
1068 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES";
1069 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
1070 return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO";
1071 case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
1072 return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT";
1073 case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
1074 return "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX";
1075 case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
1076 return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
1077 case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
1078 return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
1079 case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
1080 return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR";
1081 case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
1082 return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
1083 case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
1084 return "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO";
1085 case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR:
1086 return "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR";
1087 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
1088 return "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO";
1089 case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
1090 return "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO";
1091 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
1092 return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
1093 case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
1094 return "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT";
1095 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
1096 return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
1097 case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
1098 return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2";
1099 case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
1100 return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2";
1101 case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
1102 return "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP";
1103 case VK_STRUCTURE_TYPE_SUBMIT_INFO:
1104 return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
1105 case VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR:
1106 return "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR";
1107 case VK_STRUCTURE_TYPE_SUBPASSS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
1108 return "VK_STRUCTURE_TYPE_SUBPASSS_SHADING_PIPELINE_CREATE_INFO_HUAWEI";
1109 case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
1110 return "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO";
1111 case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
1112 return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2";
1113 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
1114 return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2";
1115 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
1116 return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE";
1117 case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
1118 return "VK_STRUCTURE_TYPE_SUBPASS_END_INFO";
1119 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
1120 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT";
1121 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
1122 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
1123 case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
1124 return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT";
1125 case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
1126 return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
1127 case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
1128 return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT";
1129 case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
1130 return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
1131 case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
1132 return "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR";
1133 case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
1134 return "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT";
1135 case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
1136 return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
1137 case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
1138 return "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD";
1139 case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
1140 return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
1141 case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
1142 return "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO";
1143 case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
1144 return "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT";
1145 case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
1146 return "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT";
1147 case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
1148 return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
1149 case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
1150 return "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT";
1151 case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
1152 return "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT";
1153 #ifdef VK_ENABLE_BETA_EXTENSIONS
1154 case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
1155 return "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR";
1156 #endif // VK_ENABLE_BETA_EXTENSIONS
1157 #ifdef VK_ENABLE_BETA_EXTENSIONS
1158 case VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR:
1159 return "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR";
1160 #endif // VK_ENABLE_BETA_EXTENSIONS
1161 #ifdef VK_ENABLE_BETA_EXTENSIONS
1162 case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
1163 return "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR";
1164 #endif // VK_ENABLE_BETA_EXTENSIONS
1165 #ifdef VK_ENABLE_BETA_EXTENSIONS
1166 case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
1167 return "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR";
1168 #endif // VK_ENABLE_BETA_EXTENSIONS
1169 #ifdef VK_ENABLE_BETA_EXTENSIONS
1170 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
1171 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT";
1172 #endif // VK_ENABLE_BETA_EXTENSIONS
1173 #ifdef VK_ENABLE_BETA_EXTENSIONS
1174 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
1175 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT";
1176 #endif // VK_ENABLE_BETA_EXTENSIONS
1177 #ifdef VK_ENABLE_BETA_EXTENSIONS
1178 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
1179 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT";
1180 #endif // VK_ENABLE_BETA_EXTENSIONS
1181 #ifdef VK_ENABLE_BETA_EXTENSIONS
1182 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
1183 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT";
1184 #endif // VK_ENABLE_BETA_EXTENSIONS
1185 #ifdef VK_ENABLE_BETA_EXTENSIONS
1186 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
1187 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT";
1188 #endif // VK_ENABLE_BETA_EXTENSIONS
1189 #ifdef VK_ENABLE_BETA_EXTENSIONS
1190 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
1191 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT";
1192 #endif // VK_ENABLE_BETA_EXTENSIONS
1193 #ifdef VK_ENABLE_BETA_EXTENSIONS
1194 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
1195 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT";
1196 #endif // VK_ENABLE_BETA_EXTENSIONS
1197 #ifdef VK_ENABLE_BETA_EXTENSIONS
1198 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
1199 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT";
1200 #endif // VK_ENABLE_BETA_EXTENSIONS
1201 #ifdef VK_ENABLE_BETA_EXTENSIONS
1202 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
1203 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT";
1204 #endif // VK_ENABLE_BETA_EXTENSIONS
1205 #ifdef VK_ENABLE_BETA_EXTENSIONS
1206 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
1207 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT";
1208 #endif // VK_ENABLE_BETA_EXTENSIONS
1209 #ifdef VK_ENABLE_BETA_EXTENSIONS
1210 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
1211 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT";
1212 #endif // VK_ENABLE_BETA_EXTENSIONS
1213 #ifdef VK_ENABLE_BETA_EXTENSIONS
1214 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
1215 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT";
1216 #endif // VK_ENABLE_BETA_EXTENSIONS
1217 #ifdef VK_ENABLE_BETA_EXTENSIONS
1218 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
1219 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT";
1220 #endif // VK_ENABLE_BETA_EXTENSIONS
1221 #ifdef VK_ENABLE_BETA_EXTENSIONS
1222 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
1223 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT";
1224 #endif // VK_ENABLE_BETA_EXTENSIONS
1225 #ifdef VK_ENABLE_BETA_EXTENSIONS
1226 case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
1227 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT";
1228 #endif // VK_ENABLE_BETA_EXTENSIONS
1229 #ifdef VK_ENABLE_BETA_EXTENSIONS
1230 case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
1231 return "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR";
1232 #endif // VK_ENABLE_BETA_EXTENSIONS
1233 #ifdef VK_ENABLE_BETA_EXTENSIONS
1234 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
1235 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT";
1236 #endif // VK_ENABLE_BETA_EXTENSIONS
1237 #ifdef VK_ENABLE_BETA_EXTENSIONS
1238 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT:
1239 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT";
1240 #endif // VK_ENABLE_BETA_EXTENSIONS
1241 #ifdef VK_ENABLE_BETA_EXTENSIONS
1242 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
1243 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT";
1244 #endif // VK_ENABLE_BETA_EXTENSIONS
1245 #ifdef VK_ENABLE_BETA_EXTENSIONS
1246 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT:
1247 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT";
1248 #endif // VK_ENABLE_BETA_EXTENSIONS
1249 #ifdef VK_ENABLE_BETA_EXTENSIONS
1250 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
1251 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT";
1252 #endif // VK_ENABLE_BETA_EXTENSIONS
1253 #ifdef VK_ENABLE_BETA_EXTENSIONS
1254 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
1255 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT";
1256 #endif // VK_ENABLE_BETA_EXTENSIONS
1257 #ifdef VK_ENABLE_BETA_EXTENSIONS
1258 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
1259 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT";
1260 #endif // VK_ENABLE_BETA_EXTENSIONS
1261 #ifdef VK_ENABLE_BETA_EXTENSIONS
1262 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
1263 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT";
1264 #endif // VK_ENABLE_BETA_EXTENSIONS
1265 #ifdef VK_ENABLE_BETA_EXTENSIONS
1266 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
1267 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT";
1268 #endif // VK_ENABLE_BETA_EXTENSIONS
1269 #ifdef VK_ENABLE_BETA_EXTENSIONS
1270 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
1271 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR";
1272 #endif // VK_ENABLE_BETA_EXTENSIONS
1273 #ifdef VK_ENABLE_BETA_EXTENSIONS
1274 case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
1275 return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR";
1276 #endif // VK_ENABLE_BETA_EXTENSIONS
1277 #ifdef VK_ENABLE_BETA_EXTENSIONS
1278 case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
1279 return "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR";
1280 #endif // VK_ENABLE_BETA_EXTENSIONS
1281 #ifdef VK_ENABLE_BETA_EXTENSIONS
1282 case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
1283 return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR";
1284 #endif // VK_ENABLE_BETA_EXTENSIONS
1285 #ifdef VK_ENABLE_BETA_EXTENSIONS
1286 case VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR:
1287 return "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR";
1288 #endif // VK_ENABLE_BETA_EXTENSIONS
1289 #ifdef VK_ENABLE_BETA_EXTENSIONS
1290 case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR:
1291 return "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR";
1292 #endif // VK_ENABLE_BETA_EXTENSIONS
1293 #ifdef VK_ENABLE_BETA_EXTENSIONS
1294 case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
1295 return "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR";
1296 #endif // VK_ENABLE_BETA_EXTENSIONS
1297 #ifdef VK_ENABLE_BETA_EXTENSIONS
1298 case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
1299 return "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR";
1300 #endif // VK_ENABLE_BETA_EXTENSIONS
1301 #ifdef VK_ENABLE_BETA_EXTENSIONS
1302 case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
1303 return "VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR";
1304 #endif // VK_ENABLE_BETA_EXTENSIONS
1305 #ifdef VK_ENABLE_BETA_EXTENSIONS
1306 case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR:
1307 return "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR";
1308 #endif // VK_ENABLE_BETA_EXTENSIONS
1309 #ifdef VK_ENABLE_BETA_EXTENSIONS
1310 case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
1311 return "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR";
1312 #endif // VK_ENABLE_BETA_EXTENSIONS
1313 #ifdef VK_ENABLE_BETA_EXTENSIONS
1314 case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
1315 return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR";
1316 #endif // VK_ENABLE_BETA_EXTENSIONS
1317 #ifdef VK_ENABLE_BETA_EXTENSIONS
1318 case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
1319 return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR";
1320 #endif // VK_ENABLE_BETA_EXTENSIONS
1321 case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
1322 return "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN";
1323 case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
1324 return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
1325 case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
1326 return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR";
1327 case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
1328 return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
1329 case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
1330 return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
1331 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
1332 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
1333 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
1334 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR";
1335 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
1336 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV";
1337 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
1338 return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT";
1339 case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
1340 return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
1341 case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
1342 return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
1343 default:
1344 return "Unhandled VkStructureType";
1345 }
1346 }
1347
string_VkAccessFlagBits(VkAccessFlagBits input_value)1348 static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value)
1349 {
1350 switch (input_value)
1351 {
1352 case VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR:
1353 return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR";
1354 case VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
1355 return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
1356 case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
1357 return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
1358 case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
1359 return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
1360 case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
1361 return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
1362 case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV:
1363 return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV";
1364 case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV:
1365 return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV";
1366 case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
1367 return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
1368 case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
1369 return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
1370 case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
1371 return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
1372 case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
1373 return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
1374 case VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
1375 return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
1376 case VK_ACCESS_HOST_READ_BIT:
1377 return "VK_ACCESS_HOST_READ_BIT";
1378 case VK_ACCESS_HOST_WRITE_BIT:
1379 return "VK_ACCESS_HOST_WRITE_BIT";
1380 case VK_ACCESS_INDEX_READ_BIT:
1381 return "VK_ACCESS_INDEX_READ_BIT";
1382 case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
1383 return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
1384 case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
1385 return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
1386 case VK_ACCESS_MEMORY_READ_BIT:
1387 return "VK_ACCESS_MEMORY_READ_BIT";
1388 case VK_ACCESS_MEMORY_WRITE_BIT:
1389 return "VK_ACCESS_MEMORY_WRITE_BIT";
1390 case VK_ACCESS_NONE_KHR:
1391 return "VK_ACCESS_NONE_KHR";
1392 case VK_ACCESS_SHADER_READ_BIT:
1393 return "VK_ACCESS_SHADER_READ_BIT";
1394 case VK_ACCESS_SHADER_WRITE_BIT:
1395 return "VK_ACCESS_SHADER_WRITE_BIT";
1396 case VK_ACCESS_TRANSFER_READ_BIT:
1397 return "VK_ACCESS_TRANSFER_READ_BIT";
1398 case VK_ACCESS_TRANSFER_WRITE_BIT:
1399 return "VK_ACCESS_TRANSFER_WRITE_BIT";
1400 case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
1401 return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
1402 case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
1403 return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
1404 case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
1405 return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
1406 case VK_ACCESS_UNIFORM_READ_BIT:
1407 return "VK_ACCESS_UNIFORM_READ_BIT";
1408 case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
1409 return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
1410 default:
1411 return "Unhandled VkAccessFlagBits";
1412 }
1413 }
1414
string_VkAccessFlags(VkAccessFlags input_value)1415 static inline std::string string_VkAccessFlags(VkAccessFlags input_value)
1416 {
1417 std::string ret;
1418 int index = 0;
1419 while(input_value) {
1420 if (input_value & 1) {
1421 if( !ret.empty()) ret.append("|");
1422 ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(1U << index)));
1423 }
1424 ++index;
1425 input_value >>= 1;
1426 }
1427 if( ret.empty()) ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(0)));
1428 return ret;
1429 }
1430
string_VkImageLayout(VkImageLayout input_value)1431 static inline const char* string_VkImageLayout(VkImageLayout input_value)
1432 {
1433 switch (input_value)
1434 {
1435 case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR:
1436 return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR";
1437 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
1438 return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
1439 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
1440 return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
1441 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
1442 return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
1443 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
1444 return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
1445 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
1446 return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
1447 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
1448 return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
1449 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
1450 return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
1451 case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
1452 return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
1453 case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
1454 return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
1455 case VK_IMAGE_LAYOUT_GENERAL:
1456 return "VK_IMAGE_LAYOUT_GENERAL";
1457 case VK_IMAGE_LAYOUT_PREINITIALIZED:
1458 return "VK_IMAGE_LAYOUT_PREINITIALIZED";
1459 case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
1460 return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
1461 case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR:
1462 return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR";
1463 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
1464 return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
1465 case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
1466 return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
1467 case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
1468 return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
1469 case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
1470 return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
1471 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
1472 return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
1473 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
1474 return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
1475 case VK_IMAGE_LAYOUT_UNDEFINED:
1476 return "VK_IMAGE_LAYOUT_UNDEFINED";
1477 #ifdef VK_ENABLE_BETA_EXTENSIONS
1478 case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
1479 return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
1480 #endif // VK_ENABLE_BETA_EXTENSIONS
1481 #ifdef VK_ENABLE_BETA_EXTENSIONS
1482 case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
1483 return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
1484 #endif // VK_ENABLE_BETA_EXTENSIONS
1485 #ifdef VK_ENABLE_BETA_EXTENSIONS
1486 case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
1487 return "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
1488 #endif // VK_ENABLE_BETA_EXTENSIONS
1489 #ifdef VK_ENABLE_BETA_EXTENSIONS
1490 case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
1491 return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
1492 #endif // VK_ENABLE_BETA_EXTENSIONS
1493 #ifdef VK_ENABLE_BETA_EXTENSIONS
1494 case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
1495 return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
1496 #endif // VK_ENABLE_BETA_EXTENSIONS
1497 #ifdef VK_ENABLE_BETA_EXTENSIONS
1498 case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
1499 return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
1500 #endif // VK_ENABLE_BETA_EXTENSIONS
1501 default:
1502 return "Unhandled VkImageLayout";
1503 }
1504 }
1505
string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)1506 static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)
1507 {
1508 switch (input_value)
1509 {
1510 case VK_IMAGE_ASPECT_COLOR_BIT:
1511 return "VK_IMAGE_ASPECT_COLOR_BIT";
1512 case VK_IMAGE_ASPECT_DEPTH_BIT:
1513 return "VK_IMAGE_ASPECT_DEPTH_BIT";
1514 case VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT:
1515 return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
1516 case VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT:
1517 return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
1518 case VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT:
1519 return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
1520 case VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT:
1521 return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
1522 case VK_IMAGE_ASPECT_METADATA_BIT:
1523 return "VK_IMAGE_ASPECT_METADATA_BIT";
1524 case VK_IMAGE_ASPECT_PLANE_0_BIT:
1525 return "VK_IMAGE_ASPECT_PLANE_0_BIT";
1526 case VK_IMAGE_ASPECT_PLANE_1_BIT:
1527 return "VK_IMAGE_ASPECT_PLANE_1_BIT";
1528 case VK_IMAGE_ASPECT_PLANE_2_BIT:
1529 return "VK_IMAGE_ASPECT_PLANE_2_BIT";
1530 case VK_IMAGE_ASPECT_STENCIL_BIT:
1531 return "VK_IMAGE_ASPECT_STENCIL_BIT";
1532 default:
1533 return "Unhandled VkImageAspectFlagBits";
1534 }
1535 }
1536
string_VkImageAspectFlags(VkImageAspectFlags input_value)1537 static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value)
1538 {
1539 std::string ret;
1540 int index = 0;
1541 while(input_value) {
1542 if (input_value & 1) {
1543 if( !ret.empty()) ret.append("|");
1544 ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(1U << index)));
1545 }
1546 ++index;
1547 input_value >>= 1;
1548 }
1549 if( ret.empty()) ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(0)));
1550 return ret;
1551 }
1552
string_VkObjectType(VkObjectType input_value)1553 static inline const char* string_VkObjectType(VkObjectType input_value)
1554 {
1555 switch (input_value)
1556 {
1557 case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR:
1558 return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR";
1559 case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV:
1560 return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV";
1561 case VK_OBJECT_TYPE_BUFFER:
1562 return "VK_OBJECT_TYPE_BUFFER";
1563 case VK_OBJECT_TYPE_BUFFER_VIEW:
1564 return "VK_OBJECT_TYPE_BUFFER_VIEW";
1565 case VK_OBJECT_TYPE_COMMAND_BUFFER:
1566 return "VK_OBJECT_TYPE_COMMAND_BUFFER";
1567 case VK_OBJECT_TYPE_COMMAND_POOL:
1568 return "VK_OBJECT_TYPE_COMMAND_POOL";
1569 case VK_OBJECT_TYPE_CU_FUNCTION_NVX:
1570 return "VK_OBJECT_TYPE_CU_FUNCTION_NVX";
1571 case VK_OBJECT_TYPE_CU_MODULE_NVX:
1572 return "VK_OBJECT_TYPE_CU_MODULE_NVX";
1573 case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
1574 return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
1575 case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
1576 return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT";
1577 case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR:
1578 return "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR";
1579 case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
1580 return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
1581 case VK_OBJECT_TYPE_DESCRIPTOR_SET:
1582 return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
1583 case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
1584 return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
1585 case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
1586 return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE";
1587 case VK_OBJECT_TYPE_DEVICE:
1588 return "VK_OBJECT_TYPE_DEVICE";
1589 case VK_OBJECT_TYPE_DEVICE_MEMORY:
1590 return "VK_OBJECT_TYPE_DEVICE_MEMORY";
1591 case VK_OBJECT_TYPE_DISPLAY_KHR:
1592 return "VK_OBJECT_TYPE_DISPLAY_KHR";
1593 case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
1594 return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
1595 case VK_OBJECT_TYPE_EVENT:
1596 return "VK_OBJECT_TYPE_EVENT";
1597 case VK_OBJECT_TYPE_FENCE:
1598 return "VK_OBJECT_TYPE_FENCE";
1599 case VK_OBJECT_TYPE_FRAMEBUFFER:
1600 return "VK_OBJECT_TYPE_FRAMEBUFFER";
1601 case VK_OBJECT_TYPE_IMAGE:
1602 return "VK_OBJECT_TYPE_IMAGE";
1603 case VK_OBJECT_TYPE_IMAGE_VIEW:
1604 return "VK_OBJECT_TYPE_IMAGE_VIEW";
1605 case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV:
1606 return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV";
1607 case VK_OBJECT_TYPE_INSTANCE:
1608 return "VK_OBJECT_TYPE_INSTANCE";
1609 case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL:
1610 return "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL";
1611 case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
1612 return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
1613 case VK_OBJECT_TYPE_PIPELINE:
1614 return "VK_OBJECT_TYPE_PIPELINE";
1615 case VK_OBJECT_TYPE_PIPELINE_CACHE:
1616 return "VK_OBJECT_TYPE_PIPELINE_CACHE";
1617 case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
1618 return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
1619 case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT:
1620 return "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT";
1621 case VK_OBJECT_TYPE_QUERY_POOL:
1622 return "VK_OBJECT_TYPE_QUERY_POOL";
1623 case VK_OBJECT_TYPE_QUEUE:
1624 return "VK_OBJECT_TYPE_QUEUE";
1625 case VK_OBJECT_TYPE_RENDER_PASS:
1626 return "VK_OBJECT_TYPE_RENDER_PASS";
1627 case VK_OBJECT_TYPE_SAMPLER:
1628 return "VK_OBJECT_TYPE_SAMPLER";
1629 case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
1630 return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION";
1631 case VK_OBJECT_TYPE_SEMAPHORE:
1632 return "VK_OBJECT_TYPE_SEMAPHORE";
1633 case VK_OBJECT_TYPE_SHADER_MODULE:
1634 return "VK_OBJECT_TYPE_SHADER_MODULE";
1635 case VK_OBJECT_TYPE_SURFACE_KHR:
1636 return "VK_OBJECT_TYPE_SURFACE_KHR";
1637 case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
1638 return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
1639 case VK_OBJECT_TYPE_UNKNOWN:
1640 return "VK_OBJECT_TYPE_UNKNOWN";
1641 case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT:
1642 return "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT";
1643 #ifdef VK_ENABLE_BETA_EXTENSIONS
1644 case VK_OBJECT_TYPE_VIDEO_SESSION_KHR:
1645 return "VK_OBJECT_TYPE_VIDEO_SESSION_KHR";
1646 #endif // VK_ENABLE_BETA_EXTENSIONS
1647 #ifdef VK_ENABLE_BETA_EXTENSIONS
1648 case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR:
1649 return "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR";
1650 #endif // VK_ENABLE_BETA_EXTENSIONS
1651 default:
1652 return "Unhandled VkObjectType";
1653 }
1654 }
1655
string_VkVendorId(VkVendorId input_value)1656 static inline const char* string_VkVendorId(VkVendorId input_value)
1657 {
1658 switch (input_value)
1659 {
1660 case VK_VENDOR_ID_CODEPLAY:
1661 return "VK_VENDOR_ID_CODEPLAY";
1662 case VK_VENDOR_ID_KAZAN:
1663 return "VK_VENDOR_ID_KAZAN";
1664 case VK_VENDOR_ID_MESA:
1665 return "VK_VENDOR_ID_MESA";
1666 case VK_VENDOR_ID_POCL:
1667 return "VK_VENDOR_ID_POCL";
1668 case VK_VENDOR_ID_VIV:
1669 return "VK_VENDOR_ID_VIV";
1670 case VK_VENDOR_ID_VSI:
1671 return "VK_VENDOR_ID_VSI";
1672 default:
1673 return "Unhandled VkVendorId";
1674 }
1675 }
1676
string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)1677 static inline const char* string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)
1678 {
1679 switch (input_value)
1680 {
1681 case VK_PIPELINE_CACHE_HEADER_VERSION_ONE:
1682 return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE";
1683 default:
1684 return "Unhandled VkPipelineCacheHeaderVersion";
1685 }
1686 }
1687
string_VkSystemAllocationScope(VkSystemAllocationScope input_value)1688 static inline const char* string_VkSystemAllocationScope(VkSystemAllocationScope input_value)
1689 {
1690 switch (input_value)
1691 {
1692 case VK_SYSTEM_ALLOCATION_SCOPE_CACHE:
1693 return "VK_SYSTEM_ALLOCATION_SCOPE_CACHE";
1694 case VK_SYSTEM_ALLOCATION_SCOPE_COMMAND:
1695 return "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND";
1696 case VK_SYSTEM_ALLOCATION_SCOPE_DEVICE:
1697 return "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE";
1698 case VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE:
1699 return "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE";
1700 case VK_SYSTEM_ALLOCATION_SCOPE_OBJECT:
1701 return "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT";
1702 default:
1703 return "Unhandled VkSystemAllocationScope";
1704 }
1705 }
1706
string_VkInternalAllocationType(VkInternalAllocationType input_value)1707 static inline const char* string_VkInternalAllocationType(VkInternalAllocationType input_value)
1708 {
1709 switch (input_value)
1710 {
1711 case VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE:
1712 return "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE";
1713 default:
1714 return "Unhandled VkInternalAllocationType";
1715 }
1716 }
1717
string_VkFormat(VkFormat input_value)1718 static inline const char* string_VkFormat(VkFormat input_value)
1719 {
1720 switch (input_value)
1721 {
1722 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1723 return "VK_FORMAT_A1R5G5B5_UNORM_PACK16";
1724 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
1725 return "VK_FORMAT_A2B10G10R10_SINT_PACK32";
1726 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
1727 return "VK_FORMAT_A2B10G10R10_SNORM_PACK32";
1728 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
1729 return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32";
1730 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1731 return "VK_FORMAT_A2B10G10R10_UINT_PACK32";
1732 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1733 return "VK_FORMAT_A2B10G10R10_UNORM_PACK32";
1734 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
1735 return "VK_FORMAT_A2B10G10R10_USCALED_PACK32";
1736 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
1737 return "VK_FORMAT_A2R10G10B10_SINT_PACK32";
1738 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1739 return "VK_FORMAT_A2R10G10B10_SNORM_PACK32";
1740 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
1741 return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32";
1742 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1743 return "VK_FORMAT_A2R10G10B10_UINT_PACK32";
1744 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1745 return "VK_FORMAT_A2R10G10B10_UNORM_PACK32";
1746 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
1747 return "VK_FORMAT_A2R10G10B10_USCALED_PACK32";
1748 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
1749 return "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT";
1750 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
1751 return "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT";
1752 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1753 return "VK_FORMAT_A8B8G8R8_SINT_PACK32";
1754 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1755 return "VK_FORMAT_A8B8G8R8_SNORM_PACK32";
1756 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1757 return "VK_FORMAT_A8B8G8R8_SRGB_PACK32";
1758 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1759 return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32";
1760 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1761 return "VK_FORMAT_A8B8G8R8_UINT_PACK32";
1762 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1763 return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
1764 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1765 return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
1766 case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT:
1767 return "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT";
1768 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1769 return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
1770 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1771 return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
1772 case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT:
1773 return "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT";
1774 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1775 return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
1776 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1777 return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
1778 case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT:
1779 return "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT";
1780 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1781 return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
1782 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1783 return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
1784 case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT:
1785 return "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT";
1786 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1787 return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
1788 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1789 return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
1790 case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT:
1791 return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT";
1792 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1793 return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
1794 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1795 return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
1796 case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT:
1797 return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT";
1798 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1799 return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
1800 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1801 return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
1802 case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT:
1803 return "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT";
1804 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1805 return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
1806 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1807 return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
1808 case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT:
1809 return "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT";
1810 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1811 return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
1812 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1813 return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
1814 case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT:
1815 return "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT";
1816 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1817 return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
1818 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1819 return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
1820 case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT:
1821 return "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT";
1822 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1823 return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
1824 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1825 return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
1826 case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT:
1827 return "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT";
1828 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1829 return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
1830 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1831 return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
1832 case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT:
1833 return "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT";
1834 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1835 return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
1836 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1837 return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
1838 case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT:
1839 return "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT";
1840 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1841 return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
1842 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1843 return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
1844 case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT:
1845 return "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT";
1846 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1847 return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
1848 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1849 return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK";
1850 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1851 return "VK_FORMAT_B10G11R11_UFLOAT_PACK32";
1852 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
1853 return "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
1854 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
1855 return "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
1856 case VK_FORMAT_B16G16R16G16_422_UNORM:
1857 return "VK_FORMAT_B16G16R16G16_422_UNORM";
1858 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1859 return "VK_FORMAT_B4G4R4A4_UNORM_PACK16";
1860 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1861 return "VK_FORMAT_B5G5R5A1_UNORM_PACK16";
1862 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1863 return "VK_FORMAT_B5G6R5_UNORM_PACK16";
1864 case VK_FORMAT_B8G8R8A8_SINT:
1865 return "VK_FORMAT_B8G8R8A8_SINT";
1866 case VK_FORMAT_B8G8R8A8_SNORM:
1867 return "VK_FORMAT_B8G8R8A8_SNORM";
1868 case VK_FORMAT_B8G8R8A8_SRGB:
1869 return "VK_FORMAT_B8G8R8A8_SRGB";
1870 case VK_FORMAT_B8G8R8A8_SSCALED:
1871 return "VK_FORMAT_B8G8R8A8_SSCALED";
1872 case VK_FORMAT_B8G8R8A8_UINT:
1873 return "VK_FORMAT_B8G8R8A8_UINT";
1874 case VK_FORMAT_B8G8R8A8_UNORM:
1875 return "VK_FORMAT_B8G8R8A8_UNORM";
1876 case VK_FORMAT_B8G8R8A8_USCALED:
1877 return "VK_FORMAT_B8G8R8A8_USCALED";
1878 case VK_FORMAT_B8G8R8G8_422_UNORM:
1879 return "VK_FORMAT_B8G8R8G8_422_UNORM";
1880 case VK_FORMAT_B8G8R8_SINT:
1881 return "VK_FORMAT_B8G8R8_SINT";
1882 case VK_FORMAT_B8G8R8_SNORM:
1883 return "VK_FORMAT_B8G8R8_SNORM";
1884 case VK_FORMAT_B8G8R8_SRGB:
1885 return "VK_FORMAT_B8G8R8_SRGB";
1886 case VK_FORMAT_B8G8R8_SSCALED:
1887 return "VK_FORMAT_B8G8R8_SSCALED";
1888 case VK_FORMAT_B8G8R8_UINT:
1889 return "VK_FORMAT_B8G8R8_UINT";
1890 case VK_FORMAT_B8G8R8_UNORM:
1891 return "VK_FORMAT_B8G8R8_UNORM";
1892 case VK_FORMAT_B8G8R8_USCALED:
1893 return "VK_FORMAT_B8G8R8_USCALED";
1894 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1895 return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK";
1896 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1897 return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK";
1898 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1899 return "VK_FORMAT_BC1_RGB_SRGB_BLOCK";
1900 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1901 return "VK_FORMAT_BC1_RGB_UNORM_BLOCK";
1902 case VK_FORMAT_BC2_SRGB_BLOCK:
1903 return "VK_FORMAT_BC2_SRGB_BLOCK";
1904 case VK_FORMAT_BC2_UNORM_BLOCK:
1905 return "VK_FORMAT_BC2_UNORM_BLOCK";
1906 case VK_FORMAT_BC3_SRGB_BLOCK:
1907 return "VK_FORMAT_BC3_SRGB_BLOCK";
1908 case VK_FORMAT_BC3_UNORM_BLOCK:
1909 return "VK_FORMAT_BC3_UNORM_BLOCK";
1910 case VK_FORMAT_BC4_SNORM_BLOCK:
1911 return "VK_FORMAT_BC4_SNORM_BLOCK";
1912 case VK_FORMAT_BC4_UNORM_BLOCK:
1913 return "VK_FORMAT_BC4_UNORM_BLOCK";
1914 case VK_FORMAT_BC5_SNORM_BLOCK:
1915 return "VK_FORMAT_BC5_SNORM_BLOCK";
1916 case VK_FORMAT_BC5_UNORM_BLOCK:
1917 return "VK_FORMAT_BC5_UNORM_BLOCK";
1918 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1919 return "VK_FORMAT_BC6H_SFLOAT_BLOCK";
1920 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1921 return "VK_FORMAT_BC6H_UFLOAT_BLOCK";
1922 case VK_FORMAT_BC7_SRGB_BLOCK:
1923 return "VK_FORMAT_BC7_SRGB_BLOCK";
1924 case VK_FORMAT_BC7_UNORM_BLOCK:
1925 return "VK_FORMAT_BC7_UNORM_BLOCK";
1926 case VK_FORMAT_D16_UNORM:
1927 return "VK_FORMAT_D16_UNORM";
1928 case VK_FORMAT_D16_UNORM_S8_UINT:
1929 return "VK_FORMAT_D16_UNORM_S8_UINT";
1930 case VK_FORMAT_D24_UNORM_S8_UINT:
1931 return "VK_FORMAT_D24_UNORM_S8_UINT";
1932 case VK_FORMAT_D32_SFLOAT:
1933 return "VK_FORMAT_D32_SFLOAT";
1934 case VK_FORMAT_D32_SFLOAT_S8_UINT:
1935 return "VK_FORMAT_D32_SFLOAT_S8_UINT";
1936 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1937 return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32";
1938 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1939 return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK";
1940 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1941 return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK";
1942 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1943 return "VK_FORMAT_EAC_R11_SNORM_BLOCK";
1944 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1945 return "VK_FORMAT_EAC_R11_UNORM_BLOCK";
1946 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1947 return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
1948 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1949 return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
1950 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1951 return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
1952 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1953 return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
1954 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1955 return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
1956 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1957 return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
1958 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
1959 return "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
1960 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
1961 return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
1962 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
1963 return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
1964 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
1965 return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT";
1966 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
1967 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
1968 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
1969 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
1970 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
1971 return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
1972 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
1973 return "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
1974 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
1975 return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
1976 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
1977 return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
1978 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
1979 return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT";
1980 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
1981 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
1982 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
1983 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
1984 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
1985 return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
1986 case VK_FORMAT_G16B16G16R16_422_UNORM:
1987 return "VK_FORMAT_G16B16G16R16_422_UNORM";
1988 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
1989 return "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM";
1990 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
1991 return "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM";
1992 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
1993 return "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT";
1994 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
1995 return "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM";
1996 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
1997 return "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM";
1998 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
1999 return "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM";
2000 case VK_FORMAT_G8B8G8R8_422_UNORM:
2001 return "VK_FORMAT_G8B8G8R8_422_UNORM";
2002 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2003 return "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM";
2004 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
2005 return "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM";
2006 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
2007 return "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT";
2008 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2009 return "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM";
2010 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
2011 return "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM";
2012 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
2013 return "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM";
2014 case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
2015 return "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
2016 case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
2017 return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
2018 case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
2019 return "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
2020 case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
2021 return "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
2022 case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
2023 return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
2024 case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
2025 return "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
2026 case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
2027 return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
2028 case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
2029 return "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
2030 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
2031 return "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
2032 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
2033 return "VK_FORMAT_R10X6G10X6_UNORM_2PACK16";
2034 case VK_FORMAT_R10X6_UNORM_PACK16:
2035 return "VK_FORMAT_R10X6_UNORM_PACK16";
2036 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
2037 return "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
2038 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
2039 return "VK_FORMAT_R12X4G12X4_UNORM_2PACK16";
2040 case VK_FORMAT_R12X4_UNORM_PACK16:
2041 return "VK_FORMAT_R12X4_UNORM_PACK16";
2042 case VK_FORMAT_R16G16B16A16_SFLOAT:
2043 return "VK_FORMAT_R16G16B16A16_SFLOAT";
2044 case VK_FORMAT_R16G16B16A16_SINT:
2045 return "VK_FORMAT_R16G16B16A16_SINT";
2046 case VK_FORMAT_R16G16B16A16_SNORM:
2047 return "VK_FORMAT_R16G16B16A16_SNORM";
2048 case VK_FORMAT_R16G16B16A16_SSCALED:
2049 return "VK_FORMAT_R16G16B16A16_SSCALED";
2050 case VK_FORMAT_R16G16B16A16_UINT:
2051 return "VK_FORMAT_R16G16B16A16_UINT";
2052 case VK_FORMAT_R16G16B16A16_UNORM:
2053 return "VK_FORMAT_R16G16B16A16_UNORM";
2054 case VK_FORMAT_R16G16B16A16_USCALED:
2055 return "VK_FORMAT_R16G16B16A16_USCALED";
2056 case VK_FORMAT_R16G16B16_SFLOAT:
2057 return "VK_FORMAT_R16G16B16_SFLOAT";
2058 case VK_FORMAT_R16G16B16_SINT:
2059 return "VK_FORMAT_R16G16B16_SINT";
2060 case VK_FORMAT_R16G16B16_SNORM:
2061 return "VK_FORMAT_R16G16B16_SNORM";
2062 case VK_FORMAT_R16G16B16_SSCALED:
2063 return "VK_FORMAT_R16G16B16_SSCALED";
2064 case VK_FORMAT_R16G16B16_UINT:
2065 return "VK_FORMAT_R16G16B16_UINT";
2066 case VK_FORMAT_R16G16B16_UNORM:
2067 return "VK_FORMAT_R16G16B16_UNORM";
2068 case VK_FORMAT_R16G16B16_USCALED:
2069 return "VK_FORMAT_R16G16B16_USCALED";
2070 case VK_FORMAT_R16G16_SFLOAT:
2071 return "VK_FORMAT_R16G16_SFLOAT";
2072 case VK_FORMAT_R16G16_SINT:
2073 return "VK_FORMAT_R16G16_SINT";
2074 case VK_FORMAT_R16G16_SNORM:
2075 return "VK_FORMAT_R16G16_SNORM";
2076 case VK_FORMAT_R16G16_SSCALED:
2077 return "VK_FORMAT_R16G16_SSCALED";
2078 case VK_FORMAT_R16G16_UINT:
2079 return "VK_FORMAT_R16G16_UINT";
2080 case VK_FORMAT_R16G16_UNORM:
2081 return "VK_FORMAT_R16G16_UNORM";
2082 case VK_FORMAT_R16G16_USCALED:
2083 return "VK_FORMAT_R16G16_USCALED";
2084 case VK_FORMAT_R16_SFLOAT:
2085 return "VK_FORMAT_R16_SFLOAT";
2086 case VK_FORMAT_R16_SINT:
2087 return "VK_FORMAT_R16_SINT";
2088 case VK_FORMAT_R16_SNORM:
2089 return "VK_FORMAT_R16_SNORM";
2090 case VK_FORMAT_R16_SSCALED:
2091 return "VK_FORMAT_R16_SSCALED";
2092 case VK_FORMAT_R16_UINT:
2093 return "VK_FORMAT_R16_UINT";
2094 case VK_FORMAT_R16_UNORM:
2095 return "VK_FORMAT_R16_UNORM";
2096 case VK_FORMAT_R16_USCALED:
2097 return "VK_FORMAT_R16_USCALED";
2098 case VK_FORMAT_R32G32B32A32_SFLOAT:
2099 return "VK_FORMAT_R32G32B32A32_SFLOAT";
2100 case VK_FORMAT_R32G32B32A32_SINT:
2101 return "VK_FORMAT_R32G32B32A32_SINT";
2102 case VK_FORMAT_R32G32B32A32_UINT:
2103 return "VK_FORMAT_R32G32B32A32_UINT";
2104 case VK_FORMAT_R32G32B32_SFLOAT:
2105 return "VK_FORMAT_R32G32B32_SFLOAT";
2106 case VK_FORMAT_R32G32B32_SINT:
2107 return "VK_FORMAT_R32G32B32_SINT";
2108 case VK_FORMAT_R32G32B32_UINT:
2109 return "VK_FORMAT_R32G32B32_UINT";
2110 case VK_FORMAT_R32G32_SFLOAT:
2111 return "VK_FORMAT_R32G32_SFLOAT";
2112 case VK_FORMAT_R32G32_SINT:
2113 return "VK_FORMAT_R32G32_SINT";
2114 case VK_FORMAT_R32G32_UINT:
2115 return "VK_FORMAT_R32G32_UINT";
2116 case VK_FORMAT_R32_SFLOAT:
2117 return "VK_FORMAT_R32_SFLOAT";
2118 case VK_FORMAT_R32_SINT:
2119 return "VK_FORMAT_R32_SINT";
2120 case VK_FORMAT_R32_UINT:
2121 return "VK_FORMAT_R32_UINT";
2122 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2123 return "VK_FORMAT_R4G4B4A4_UNORM_PACK16";
2124 case VK_FORMAT_R4G4_UNORM_PACK8:
2125 return "VK_FORMAT_R4G4_UNORM_PACK8";
2126 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2127 return "VK_FORMAT_R5G5B5A1_UNORM_PACK16";
2128 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2129 return "VK_FORMAT_R5G6B5_UNORM_PACK16";
2130 case VK_FORMAT_R64G64B64A64_SFLOAT:
2131 return "VK_FORMAT_R64G64B64A64_SFLOAT";
2132 case VK_FORMAT_R64G64B64A64_SINT:
2133 return "VK_FORMAT_R64G64B64A64_SINT";
2134 case VK_FORMAT_R64G64B64A64_UINT:
2135 return "VK_FORMAT_R64G64B64A64_UINT";
2136 case VK_FORMAT_R64G64B64_SFLOAT:
2137 return "VK_FORMAT_R64G64B64_SFLOAT";
2138 case VK_FORMAT_R64G64B64_SINT:
2139 return "VK_FORMAT_R64G64B64_SINT";
2140 case VK_FORMAT_R64G64B64_UINT:
2141 return "VK_FORMAT_R64G64B64_UINT";
2142 case VK_FORMAT_R64G64_SFLOAT:
2143 return "VK_FORMAT_R64G64_SFLOAT";
2144 case VK_FORMAT_R64G64_SINT:
2145 return "VK_FORMAT_R64G64_SINT";
2146 case VK_FORMAT_R64G64_UINT:
2147 return "VK_FORMAT_R64G64_UINT";
2148 case VK_FORMAT_R64_SFLOAT:
2149 return "VK_FORMAT_R64_SFLOAT";
2150 case VK_FORMAT_R64_SINT:
2151 return "VK_FORMAT_R64_SINT";
2152 case VK_FORMAT_R64_UINT:
2153 return "VK_FORMAT_R64_UINT";
2154 case VK_FORMAT_R8G8B8A8_SINT:
2155 return "VK_FORMAT_R8G8B8A8_SINT";
2156 case VK_FORMAT_R8G8B8A8_SNORM:
2157 return "VK_FORMAT_R8G8B8A8_SNORM";
2158 case VK_FORMAT_R8G8B8A8_SRGB:
2159 return "VK_FORMAT_R8G8B8A8_SRGB";
2160 case VK_FORMAT_R8G8B8A8_SSCALED:
2161 return "VK_FORMAT_R8G8B8A8_SSCALED";
2162 case VK_FORMAT_R8G8B8A8_UINT:
2163 return "VK_FORMAT_R8G8B8A8_UINT";
2164 case VK_FORMAT_R8G8B8A8_UNORM:
2165 return "VK_FORMAT_R8G8B8A8_UNORM";
2166 case VK_FORMAT_R8G8B8A8_USCALED:
2167 return "VK_FORMAT_R8G8B8A8_USCALED";
2168 case VK_FORMAT_R8G8B8_SINT:
2169 return "VK_FORMAT_R8G8B8_SINT";
2170 case VK_FORMAT_R8G8B8_SNORM:
2171 return "VK_FORMAT_R8G8B8_SNORM";
2172 case VK_FORMAT_R8G8B8_SRGB:
2173 return "VK_FORMAT_R8G8B8_SRGB";
2174 case VK_FORMAT_R8G8B8_SSCALED:
2175 return "VK_FORMAT_R8G8B8_SSCALED";
2176 case VK_FORMAT_R8G8B8_UINT:
2177 return "VK_FORMAT_R8G8B8_UINT";
2178 case VK_FORMAT_R8G8B8_UNORM:
2179 return "VK_FORMAT_R8G8B8_UNORM";
2180 case VK_FORMAT_R8G8B8_USCALED:
2181 return "VK_FORMAT_R8G8B8_USCALED";
2182 case VK_FORMAT_R8G8_SINT:
2183 return "VK_FORMAT_R8G8_SINT";
2184 case VK_FORMAT_R8G8_SNORM:
2185 return "VK_FORMAT_R8G8_SNORM";
2186 case VK_FORMAT_R8G8_SRGB:
2187 return "VK_FORMAT_R8G8_SRGB";
2188 case VK_FORMAT_R8G8_SSCALED:
2189 return "VK_FORMAT_R8G8_SSCALED";
2190 case VK_FORMAT_R8G8_UINT:
2191 return "VK_FORMAT_R8G8_UINT";
2192 case VK_FORMAT_R8G8_UNORM:
2193 return "VK_FORMAT_R8G8_UNORM";
2194 case VK_FORMAT_R8G8_USCALED:
2195 return "VK_FORMAT_R8G8_USCALED";
2196 case VK_FORMAT_R8_SINT:
2197 return "VK_FORMAT_R8_SINT";
2198 case VK_FORMAT_R8_SNORM:
2199 return "VK_FORMAT_R8_SNORM";
2200 case VK_FORMAT_R8_SRGB:
2201 return "VK_FORMAT_R8_SRGB";
2202 case VK_FORMAT_R8_SSCALED:
2203 return "VK_FORMAT_R8_SSCALED";
2204 case VK_FORMAT_R8_UINT:
2205 return "VK_FORMAT_R8_UINT";
2206 case VK_FORMAT_R8_UNORM:
2207 return "VK_FORMAT_R8_UNORM";
2208 case VK_FORMAT_R8_USCALED:
2209 return "VK_FORMAT_R8_USCALED";
2210 case VK_FORMAT_S8_UINT:
2211 return "VK_FORMAT_S8_UINT";
2212 case VK_FORMAT_UNDEFINED:
2213 return "VK_FORMAT_UNDEFINED";
2214 case VK_FORMAT_X8_D24_UNORM_PACK32:
2215 return "VK_FORMAT_X8_D24_UNORM_PACK32";
2216 default:
2217 return "Unhandled VkFormat";
2218 }
2219 }
2220
string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value)2221 static inline const char* string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value)
2222 {
2223 switch (input_value)
2224 {
2225 case VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR:
2226 return "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
2227 case VK_FORMAT_FEATURE_BLIT_DST_BIT:
2228 return "VK_FORMAT_FEATURE_BLIT_DST_BIT";
2229 case VK_FORMAT_FEATURE_BLIT_SRC_BIT:
2230 return "VK_FORMAT_FEATURE_BLIT_SRC_BIT";
2231 case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT:
2232 return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT";
2233 case VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT:
2234 return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT";
2235 case VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT:
2236 return "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT";
2237 case VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT:
2238 return "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT";
2239 case VK_FORMAT_FEATURE_DISJOINT_BIT:
2240 return "VK_FORMAT_FEATURE_DISJOINT_BIT";
2241 case VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT:
2242 return "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT";
2243 case VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
2244 return "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
2245 case VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT:
2246 return "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT";
2247 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT:
2248 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT";
2249 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG:
2250 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG";
2251 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT:
2252 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
2253 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT:
2254 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
2255 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT:
2256 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
2257 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT:
2258 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
2259 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT:
2260 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
2261 case VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT:
2262 return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
2263 case VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT:
2264 return "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT";
2265 case VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT:
2266 return "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT";
2267 case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT:
2268 return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
2269 case VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT:
2270 return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT";
2271 case VK_FORMAT_FEATURE_TRANSFER_DST_BIT:
2272 return "VK_FORMAT_FEATURE_TRANSFER_DST_BIT";
2273 case VK_FORMAT_FEATURE_TRANSFER_SRC_BIT:
2274 return "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT";
2275 case VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT:
2276 return "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT";
2277 case VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT:
2278 return "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT";
2279 #ifdef VK_ENABLE_BETA_EXTENSIONS
2280 case VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR:
2281 return "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR";
2282 #endif // VK_ENABLE_BETA_EXTENSIONS
2283 #ifdef VK_ENABLE_BETA_EXTENSIONS
2284 case VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR:
2285 return "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR";
2286 #endif // VK_ENABLE_BETA_EXTENSIONS
2287 #ifdef VK_ENABLE_BETA_EXTENSIONS
2288 case VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR:
2289 return "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR";
2290 #endif // VK_ENABLE_BETA_EXTENSIONS
2291 #ifdef VK_ENABLE_BETA_EXTENSIONS
2292 case VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR:
2293 return "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR";
2294 #endif // VK_ENABLE_BETA_EXTENSIONS
2295 default:
2296 return "Unhandled VkFormatFeatureFlagBits";
2297 }
2298 }
2299
string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value)2300 static inline std::string string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value)
2301 {
2302 std::string ret;
2303 int index = 0;
2304 while(input_value) {
2305 if (input_value & 1) {
2306 if( !ret.empty()) ret.append("|");
2307 ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(1U << index)));
2308 }
2309 ++index;
2310 input_value >>= 1;
2311 }
2312 if( ret.empty()) ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(0)));
2313 return ret;
2314 }
2315
string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)2316 static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)
2317 {
2318 switch (input_value)
2319 {
2320 case VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT:
2321 return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT";
2322 case VK_IMAGE_CREATE_ALIAS_BIT:
2323 return "VK_IMAGE_CREATE_ALIAS_BIT";
2324 case VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT:
2325 return "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT";
2326 case VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV:
2327 return "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV";
2328 case VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
2329 return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT";
2330 case VK_IMAGE_CREATE_DISJOINT_BIT:
2331 return "VK_IMAGE_CREATE_DISJOINT_BIT";
2332 case VK_IMAGE_CREATE_EXTENDED_USAGE_BIT:
2333 return "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT";
2334 case VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
2335 return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
2336 case VK_IMAGE_CREATE_PROTECTED_BIT:
2337 return "VK_IMAGE_CREATE_PROTECTED_BIT";
2338 case VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT:
2339 return "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT";
2340 case VK_IMAGE_CREATE_SPARSE_ALIASED_BIT:
2341 return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT";
2342 case VK_IMAGE_CREATE_SPARSE_BINDING_BIT:
2343 return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT";
2344 case VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT:
2345 return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT";
2346 case VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT:
2347 return "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT";
2348 case VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT:
2349 return "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT";
2350 default:
2351 return "Unhandled VkImageCreateFlagBits";
2352 }
2353 }
2354
string_VkImageCreateFlags(VkImageCreateFlags input_value)2355 static inline std::string string_VkImageCreateFlags(VkImageCreateFlags input_value)
2356 {
2357 std::string ret;
2358 int index = 0;
2359 while(input_value) {
2360 if (input_value & 1) {
2361 if( !ret.empty()) ret.append("|");
2362 ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(1U << index)));
2363 }
2364 ++index;
2365 input_value >>= 1;
2366 }
2367 if( ret.empty()) ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(0)));
2368 return ret;
2369 }
2370
string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)2371 static inline const char* string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)
2372 {
2373 switch (input_value)
2374 {
2375 case VK_SAMPLE_COUNT_16_BIT:
2376 return "VK_SAMPLE_COUNT_16_BIT";
2377 case VK_SAMPLE_COUNT_1_BIT:
2378 return "VK_SAMPLE_COUNT_1_BIT";
2379 case VK_SAMPLE_COUNT_2_BIT:
2380 return "VK_SAMPLE_COUNT_2_BIT";
2381 case VK_SAMPLE_COUNT_32_BIT:
2382 return "VK_SAMPLE_COUNT_32_BIT";
2383 case VK_SAMPLE_COUNT_4_BIT:
2384 return "VK_SAMPLE_COUNT_4_BIT";
2385 case VK_SAMPLE_COUNT_64_BIT:
2386 return "VK_SAMPLE_COUNT_64_BIT";
2387 case VK_SAMPLE_COUNT_8_BIT:
2388 return "VK_SAMPLE_COUNT_8_BIT";
2389 default:
2390 return "Unhandled VkSampleCountFlagBits";
2391 }
2392 }
2393
string_VkSampleCountFlags(VkSampleCountFlags input_value)2394 static inline std::string string_VkSampleCountFlags(VkSampleCountFlags input_value)
2395 {
2396 std::string ret;
2397 int index = 0;
2398 while(input_value) {
2399 if (input_value & 1) {
2400 if( !ret.empty()) ret.append("|");
2401 ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(1U << index)));
2402 }
2403 ++index;
2404 input_value >>= 1;
2405 }
2406 if( ret.empty()) ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(0)));
2407 return ret;
2408 }
2409
string_VkImageTiling(VkImageTiling input_value)2410 static inline const char* string_VkImageTiling(VkImageTiling input_value)
2411 {
2412 switch (input_value)
2413 {
2414 case VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT:
2415 return "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
2416 case VK_IMAGE_TILING_LINEAR:
2417 return "VK_IMAGE_TILING_LINEAR";
2418 case VK_IMAGE_TILING_OPTIMAL:
2419 return "VK_IMAGE_TILING_OPTIMAL";
2420 default:
2421 return "Unhandled VkImageTiling";
2422 }
2423 }
2424
string_VkImageType(VkImageType input_value)2425 static inline const char* string_VkImageType(VkImageType input_value)
2426 {
2427 switch (input_value)
2428 {
2429 case VK_IMAGE_TYPE_1D:
2430 return "VK_IMAGE_TYPE_1D";
2431 case VK_IMAGE_TYPE_2D:
2432 return "VK_IMAGE_TYPE_2D";
2433 case VK_IMAGE_TYPE_3D:
2434 return "VK_IMAGE_TYPE_3D";
2435 default:
2436 return "Unhandled VkImageType";
2437 }
2438 }
2439
string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)2440 static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)
2441 {
2442 switch (input_value)
2443 {
2444 case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
2445 return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
2446 case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
2447 return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
2448 case VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT:
2449 return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT";
2450 case VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
2451 return "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
2452 case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
2453 return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
2454 case VK_IMAGE_USAGE_SAMPLED_BIT:
2455 return "VK_IMAGE_USAGE_SAMPLED_BIT";
2456 case VK_IMAGE_USAGE_STORAGE_BIT:
2457 return "VK_IMAGE_USAGE_STORAGE_BIT";
2458 case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
2459 return "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
2460 case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
2461 return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
2462 case VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT:
2463 return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
2464 #ifdef VK_ENABLE_BETA_EXTENSIONS
2465 case VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR:
2466 return "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR";
2467 #endif // VK_ENABLE_BETA_EXTENSIONS
2468 #ifdef VK_ENABLE_BETA_EXTENSIONS
2469 case VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR:
2470 return "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR";
2471 #endif // VK_ENABLE_BETA_EXTENSIONS
2472 #ifdef VK_ENABLE_BETA_EXTENSIONS
2473 case VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR:
2474 return "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
2475 #endif // VK_ENABLE_BETA_EXTENSIONS
2476 #ifdef VK_ENABLE_BETA_EXTENSIONS
2477 case VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR:
2478 return "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR";
2479 #endif // VK_ENABLE_BETA_EXTENSIONS
2480 #ifdef VK_ENABLE_BETA_EXTENSIONS
2481 case VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR:
2482 return "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
2483 #endif // VK_ENABLE_BETA_EXTENSIONS
2484 #ifdef VK_ENABLE_BETA_EXTENSIONS
2485 case VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR:
2486 return "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
2487 #endif // VK_ENABLE_BETA_EXTENSIONS
2488 default:
2489 return "Unhandled VkImageUsageFlagBits";
2490 }
2491 }
2492
string_VkImageUsageFlags(VkImageUsageFlags input_value)2493 static inline std::string string_VkImageUsageFlags(VkImageUsageFlags input_value)
2494 {
2495 std::string ret;
2496 int index = 0;
2497 while(input_value) {
2498 if (input_value & 1) {
2499 if( !ret.empty()) ret.append("|");
2500 ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(1U << index)));
2501 }
2502 ++index;
2503 input_value >>= 1;
2504 }
2505 if( ret.empty()) ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(0)));
2506 return ret;
2507 }
2508
string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)2509 static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)
2510 {
2511 switch (input_value)
2512 {
2513 case VK_MEMORY_HEAP_DEVICE_LOCAL_BIT:
2514 return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
2515 case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT:
2516 return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
2517 default:
2518 return "Unhandled VkMemoryHeapFlagBits";
2519 }
2520 }
2521
string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value)2522 static inline std::string string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value)
2523 {
2524 std::string ret;
2525 int index = 0;
2526 while(input_value) {
2527 if (input_value & 1) {
2528 if( !ret.empty()) ret.append("|");
2529 ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(1U << index)));
2530 }
2531 ++index;
2532 input_value >>= 1;
2533 }
2534 if( ret.empty()) ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(0)));
2535 return ret;
2536 }
2537
string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)2538 static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)
2539 {
2540 switch (input_value)
2541 {
2542 case VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD:
2543 return "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD";
2544 case VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT:
2545 return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
2546 case VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD:
2547 return "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD";
2548 case VK_MEMORY_PROPERTY_HOST_CACHED_BIT:
2549 return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
2550 case VK_MEMORY_PROPERTY_HOST_COHERENT_BIT:
2551 return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT";
2552 case VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT:
2553 return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT";
2554 case VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT:
2555 return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT";
2556 case VK_MEMORY_PROPERTY_PROTECTED_BIT:
2557 return "VK_MEMORY_PROPERTY_PROTECTED_BIT";
2558 default:
2559 return "Unhandled VkMemoryPropertyFlagBits";
2560 }
2561 }
2562
string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value)2563 static inline std::string string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value)
2564 {
2565 std::string ret;
2566 int index = 0;
2567 while(input_value) {
2568 if (input_value & 1) {
2569 if( !ret.empty()) ret.append("|");
2570 ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(1U << index)));
2571 }
2572 ++index;
2573 input_value >>= 1;
2574 }
2575 if( ret.empty()) ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(0)));
2576 return ret;
2577 }
2578
string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)2579 static inline const char* string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)
2580 {
2581 switch (input_value)
2582 {
2583 case VK_PHYSICAL_DEVICE_TYPE_CPU:
2584 return "VK_PHYSICAL_DEVICE_TYPE_CPU";
2585 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
2586 return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
2587 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
2588 return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
2589 case VK_PHYSICAL_DEVICE_TYPE_OTHER:
2590 return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
2591 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
2592 return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
2593 default:
2594 return "Unhandled VkPhysicalDeviceType";
2595 }
2596 }
2597
string_VkQueueFlagBits(VkQueueFlagBits input_value)2598 static inline const char* string_VkQueueFlagBits(VkQueueFlagBits input_value)
2599 {
2600 switch (input_value)
2601 {
2602 case VK_QUEUE_COMPUTE_BIT:
2603 return "VK_QUEUE_COMPUTE_BIT";
2604 case VK_QUEUE_GRAPHICS_BIT:
2605 return "VK_QUEUE_GRAPHICS_BIT";
2606 case VK_QUEUE_PROTECTED_BIT:
2607 return "VK_QUEUE_PROTECTED_BIT";
2608 case VK_QUEUE_SPARSE_BINDING_BIT:
2609 return "VK_QUEUE_SPARSE_BINDING_BIT";
2610 case VK_QUEUE_TRANSFER_BIT:
2611 return "VK_QUEUE_TRANSFER_BIT";
2612 #ifdef VK_ENABLE_BETA_EXTENSIONS
2613 case VK_QUEUE_VIDEO_DECODE_BIT_KHR:
2614 return "VK_QUEUE_VIDEO_DECODE_BIT_KHR";
2615 #endif // VK_ENABLE_BETA_EXTENSIONS
2616 #ifdef VK_ENABLE_BETA_EXTENSIONS
2617 case VK_QUEUE_VIDEO_ENCODE_BIT_KHR:
2618 return "VK_QUEUE_VIDEO_ENCODE_BIT_KHR";
2619 #endif // VK_ENABLE_BETA_EXTENSIONS
2620 default:
2621 return "Unhandled VkQueueFlagBits";
2622 }
2623 }
2624
string_VkQueueFlags(VkQueueFlags input_value)2625 static inline std::string string_VkQueueFlags(VkQueueFlags input_value)
2626 {
2627 std::string ret;
2628 int index = 0;
2629 while(input_value) {
2630 if (input_value & 1) {
2631 if( !ret.empty()) ret.append("|");
2632 ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(1U << index)));
2633 }
2634 ++index;
2635 input_value >>= 1;
2636 }
2637 if( ret.empty()) ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(0)));
2638 return ret;
2639 }
2640
string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value)2641 static inline const char* string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value)
2642 {
2643 switch (input_value)
2644 {
2645 case VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT:
2646 return "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT";
2647 default:
2648 return "Unhandled VkDeviceQueueCreateFlagBits";
2649 }
2650 }
2651
string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value)2652 static inline std::string string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value)
2653 {
2654 std::string ret;
2655 int index = 0;
2656 while(input_value) {
2657 if (input_value & 1) {
2658 if( !ret.empty()) ret.append("|");
2659 ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(1U << index)));
2660 }
2661 ++index;
2662 input_value >>= 1;
2663 }
2664 if( ret.empty()) ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(0)));
2665 return ret;
2666 }
2667
string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)2668 static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)
2669 {
2670 switch (input_value)
2671 {
2672 case VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
2673 return "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
2674 case VK_PIPELINE_STAGE_ALL_COMMANDS_BIT:
2675 return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT";
2676 case VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
2677 return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT";
2678 case VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
2679 return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT";
2680 case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
2681 return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT";
2682 case VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV:
2683 return "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV";
2684 case VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
2685 return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT";
2686 case VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT:
2687 return "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT";
2688 case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
2689 return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT";
2690 case VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
2691 return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT";
2692 case VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
2693 return "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
2694 case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
2695 return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT";
2696 case VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
2697 return "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
2698 case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
2699 return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT";
2700 case VK_PIPELINE_STAGE_HOST_BIT:
2701 return "VK_PIPELINE_STAGE_HOST_BIT";
2702 case VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
2703 return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT";
2704 case VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV:
2705 return "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV";
2706 case VK_PIPELINE_STAGE_NONE_KHR:
2707 return "VK_PIPELINE_STAGE_NONE_KHR";
2708 case VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR:
2709 return "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR";
2710 case VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV:
2711 return "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV";
2712 case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
2713 return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT";
2714 case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
2715 return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT";
2716 case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
2717 return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT";
2718 case VK_PIPELINE_STAGE_TRANSFER_BIT:
2719 return "VK_PIPELINE_STAGE_TRANSFER_BIT";
2720 case VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT:
2721 return "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT";
2722 case VK_PIPELINE_STAGE_VERTEX_INPUT_BIT:
2723 return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT";
2724 case VK_PIPELINE_STAGE_VERTEX_SHADER_BIT:
2725 return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT";
2726 default:
2727 return "Unhandled VkPipelineStageFlagBits";
2728 }
2729 }
2730
string_VkPipelineStageFlags(VkPipelineStageFlags input_value)2731 static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input_value)
2732 {
2733 std::string ret;
2734 int index = 0;
2735 while(input_value) {
2736 if (input_value & 1) {
2737 if( !ret.empty()) ret.append("|");
2738 ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(1U << index)));
2739 }
2740 ++index;
2741 input_value >>= 1;
2742 }
2743 if( ret.empty()) ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(0)));
2744 return ret;
2745 }
2746
string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)2747 static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)
2748 {
2749 switch (input_value)
2750 {
2751 case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
2752 return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
2753 default:
2754 return "Unhandled VkSparseMemoryBindFlagBits";
2755 }
2756 }
2757
string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value)2758 static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value)
2759 {
2760 std::string ret;
2761 int index = 0;
2762 while(input_value) {
2763 if (input_value & 1) {
2764 if( !ret.empty()) ret.append("|");
2765 ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(1U << index)));
2766 }
2767 ++index;
2768 input_value >>= 1;
2769 }
2770 if( ret.empty()) ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(0)));
2771 return ret;
2772 }
2773
string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)2774 static inline const char* string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)
2775 {
2776 switch (input_value)
2777 {
2778 case VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT:
2779 return "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT";
2780 case VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT:
2781 return "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT";
2782 case VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT:
2783 return "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT";
2784 default:
2785 return "Unhandled VkSparseImageFormatFlagBits";
2786 }
2787 }
2788
string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value)2789 static inline std::string string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value)
2790 {
2791 std::string ret;
2792 int index = 0;
2793 while(input_value) {
2794 if (input_value & 1) {
2795 if( !ret.empty()) ret.append("|");
2796 ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(1U << index)));
2797 }
2798 ++index;
2799 input_value >>= 1;
2800 }
2801 if( ret.empty()) ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(0)));
2802 return ret;
2803 }
2804
string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)2805 static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)
2806 {
2807 switch (input_value)
2808 {
2809 case VK_FENCE_CREATE_SIGNALED_BIT:
2810 return "VK_FENCE_CREATE_SIGNALED_BIT";
2811 default:
2812 return "Unhandled VkFenceCreateFlagBits";
2813 }
2814 }
2815
string_VkFenceCreateFlags(VkFenceCreateFlags input_value)2816 static inline std::string string_VkFenceCreateFlags(VkFenceCreateFlags input_value)
2817 {
2818 std::string ret;
2819 int index = 0;
2820 while(input_value) {
2821 if (input_value & 1) {
2822 if( !ret.empty()) ret.append("|");
2823 ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(1U << index)));
2824 }
2825 ++index;
2826 input_value >>= 1;
2827 }
2828 if( ret.empty()) ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(0)));
2829 return ret;
2830 }
2831
string_VkEventCreateFlagBits(VkEventCreateFlagBits input_value)2832 static inline const char* string_VkEventCreateFlagBits(VkEventCreateFlagBits input_value)
2833 {
2834 switch (input_value)
2835 {
2836 case VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR:
2837 return "VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR";
2838 default:
2839 return "Unhandled VkEventCreateFlagBits";
2840 }
2841 }
2842
string_VkEventCreateFlags(VkEventCreateFlags input_value)2843 static inline std::string string_VkEventCreateFlags(VkEventCreateFlags input_value)
2844 {
2845 std::string ret;
2846 int index = 0;
2847 while(input_value) {
2848 if (input_value & 1) {
2849 if( !ret.empty()) ret.append("|");
2850 ret.append(string_VkEventCreateFlagBits(static_cast<VkEventCreateFlagBits>(1U << index)));
2851 }
2852 ++index;
2853 input_value >>= 1;
2854 }
2855 if( ret.empty()) ret.append(string_VkEventCreateFlagBits(static_cast<VkEventCreateFlagBits>(0)));
2856 return ret;
2857 }
2858
string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)2859 static inline const char* string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)
2860 {
2861 switch (input_value)
2862 {
2863 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT:
2864 return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT";
2865 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT:
2866 return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT";
2867 case VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT:
2868 return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT";
2869 case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
2870 return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT";
2871 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT:
2872 return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT";
2873 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT:
2874 return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT";
2875 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
2876 return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT";
2877 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
2878 return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT";
2879 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT:
2880 return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT";
2881 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT:
2882 return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT";
2883 case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
2884 return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT";
2885 default:
2886 return "Unhandled VkQueryPipelineStatisticFlagBits";
2887 }
2888 }
2889
string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags input_value)2890 static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags 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_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(1U << index)));
2898 }
2899 ++index;
2900 input_value >>= 1;
2901 }
2902 if( ret.empty()) ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(0)));
2903 return ret;
2904 }
2905
string_VkQueryType(VkQueryType input_value)2906 static inline const char* string_VkQueryType(VkQueryType input_value)
2907 {
2908 switch (input_value)
2909 {
2910 case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR:
2911 return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR";
2912 case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV:
2913 return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV";
2914 case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR:
2915 return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR";
2916 case VK_QUERY_TYPE_OCCLUSION:
2917 return "VK_QUERY_TYPE_OCCLUSION";
2918 case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL:
2919 return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL";
2920 case VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR:
2921 return "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR";
2922 case VK_QUERY_TYPE_PIPELINE_STATISTICS:
2923 return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
2924 #ifdef VK_ENABLE_BETA_EXTENSIONS
2925 case VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR:
2926 return "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR";
2927 #endif // VK_ENABLE_BETA_EXTENSIONS
2928 case VK_QUERY_TYPE_TIMESTAMP:
2929 return "VK_QUERY_TYPE_TIMESTAMP";
2930 case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT:
2931 return "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT";
2932 #ifdef VK_ENABLE_BETA_EXTENSIONS
2933 case VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR:
2934 return "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR";
2935 #endif // VK_ENABLE_BETA_EXTENSIONS
2936 default:
2937 return "Unhandled VkQueryType";
2938 }
2939 }
2940
string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)2941 static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)
2942 {
2943 switch (input_value)
2944 {
2945 case VK_QUERY_RESULT_64_BIT:
2946 return "VK_QUERY_RESULT_64_BIT";
2947 case VK_QUERY_RESULT_PARTIAL_BIT:
2948 return "VK_QUERY_RESULT_PARTIAL_BIT";
2949 case VK_QUERY_RESULT_WAIT_BIT:
2950 return "VK_QUERY_RESULT_WAIT_BIT";
2951 case VK_QUERY_RESULT_WITH_AVAILABILITY_BIT:
2952 return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT";
2953 #ifdef VK_ENABLE_BETA_EXTENSIONS
2954 case VK_QUERY_RESULT_WITH_STATUS_BIT_KHR:
2955 return "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR";
2956 #endif // VK_ENABLE_BETA_EXTENSIONS
2957 default:
2958 return "Unhandled VkQueryResultFlagBits";
2959 }
2960 }
2961
string_VkQueryResultFlags(VkQueryResultFlags input_value)2962 static inline std::string string_VkQueryResultFlags(VkQueryResultFlags input_value)
2963 {
2964 std::string ret;
2965 int index = 0;
2966 while(input_value) {
2967 if (input_value & 1) {
2968 if( !ret.empty()) ret.append("|");
2969 ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(1U << index)));
2970 }
2971 ++index;
2972 input_value >>= 1;
2973 }
2974 if( ret.empty()) ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(0)));
2975 return ret;
2976 }
2977
string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)2978 static inline const char* string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)
2979 {
2980 switch (input_value)
2981 {
2982 case VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
2983 return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
2984 case VK_BUFFER_CREATE_PROTECTED_BIT:
2985 return "VK_BUFFER_CREATE_PROTECTED_BIT";
2986 case VK_BUFFER_CREATE_SPARSE_ALIASED_BIT:
2987 return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT";
2988 case VK_BUFFER_CREATE_SPARSE_BINDING_BIT:
2989 return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT";
2990 case VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT:
2991 return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT";
2992 default:
2993 return "Unhandled VkBufferCreateFlagBits";
2994 }
2995 }
2996
string_VkBufferCreateFlags(VkBufferCreateFlags input_value)2997 static inline std::string string_VkBufferCreateFlags(VkBufferCreateFlags input_value)
2998 {
2999 std::string ret;
3000 int index = 0;
3001 while(input_value) {
3002 if (input_value & 1) {
3003 if( !ret.empty()) ret.append("|");
3004 ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(1U << index)));
3005 }
3006 ++index;
3007 input_value >>= 1;
3008 }
3009 if( ret.empty()) ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(0)));
3010 return ret;
3011 }
3012
string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)3013 static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)
3014 {
3015 switch (input_value)
3016 {
3017 case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR:
3018 return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
3019 case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR:
3020 return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
3021 case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT:
3022 return "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT";
3023 case VK_BUFFER_USAGE_INDEX_BUFFER_BIT:
3024 return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
3025 case VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT:
3026 return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
3027 case VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR:
3028 return "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR";
3029 case VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT:
3030 return "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT";
3031 case VK_BUFFER_USAGE_STORAGE_BUFFER_BIT:
3032 return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT";
3033 case VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT:
3034 return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT";
3035 case VK_BUFFER_USAGE_TRANSFER_DST_BIT:
3036 return "VK_BUFFER_USAGE_TRANSFER_DST_BIT";
3037 case VK_BUFFER_USAGE_TRANSFER_SRC_BIT:
3038 return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT";
3039 case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT:
3040 return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
3041 case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT:
3042 return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
3043 case VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT:
3044 return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT";
3045 case VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT:
3046 return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT";
3047 case VK_BUFFER_USAGE_VERTEX_BUFFER_BIT:
3048 return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
3049 #ifdef VK_ENABLE_BETA_EXTENSIONS
3050 case VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR:
3051 return "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR";
3052 #endif // VK_ENABLE_BETA_EXTENSIONS
3053 #ifdef VK_ENABLE_BETA_EXTENSIONS
3054 case VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR:
3055 return "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
3056 #endif // VK_ENABLE_BETA_EXTENSIONS
3057 #ifdef VK_ENABLE_BETA_EXTENSIONS
3058 case VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR:
3059 return "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
3060 #endif // VK_ENABLE_BETA_EXTENSIONS
3061 #ifdef VK_ENABLE_BETA_EXTENSIONS
3062 case VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR:
3063 return "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
3064 #endif // VK_ENABLE_BETA_EXTENSIONS
3065 default:
3066 return "Unhandled VkBufferUsageFlagBits";
3067 }
3068 }
3069
string_VkBufferUsageFlags(VkBufferUsageFlags input_value)3070 static inline std::string string_VkBufferUsageFlags(VkBufferUsageFlags input_value)
3071 {
3072 std::string ret;
3073 int index = 0;
3074 while(input_value) {
3075 if (input_value & 1) {
3076 if( !ret.empty()) ret.append("|");
3077 ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(1U << index)));
3078 }
3079 ++index;
3080 input_value >>= 1;
3081 }
3082 if( ret.empty()) ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(0)));
3083 return ret;
3084 }
3085
string_VkSharingMode(VkSharingMode input_value)3086 static inline const char* string_VkSharingMode(VkSharingMode input_value)
3087 {
3088 switch (input_value)
3089 {
3090 case VK_SHARING_MODE_CONCURRENT:
3091 return "VK_SHARING_MODE_CONCURRENT";
3092 case VK_SHARING_MODE_EXCLUSIVE:
3093 return "VK_SHARING_MODE_EXCLUSIVE";
3094 default:
3095 return "Unhandled VkSharingMode";
3096 }
3097 }
3098
string_VkComponentSwizzle(VkComponentSwizzle input_value)3099 static inline const char* string_VkComponentSwizzle(VkComponentSwizzle input_value)
3100 {
3101 switch (input_value)
3102 {
3103 case VK_COMPONENT_SWIZZLE_A:
3104 return "VK_COMPONENT_SWIZZLE_A";
3105 case VK_COMPONENT_SWIZZLE_B:
3106 return "VK_COMPONENT_SWIZZLE_B";
3107 case VK_COMPONENT_SWIZZLE_G:
3108 return "VK_COMPONENT_SWIZZLE_G";
3109 case VK_COMPONENT_SWIZZLE_IDENTITY:
3110 return "VK_COMPONENT_SWIZZLE_IDENTITY";
3111 case VK_COMPONENT_SWIZZLE_ONE:
3112 return "VK_COMPONENT_SWIZZLE_ONE";
3113 case VK_COMPONENT_SWIZZLE_R:
3114 return "VK_COMPONENT_SWIZZLE_R";
3115 case VK_COMPONENT_SWIZZLE_ZERO:
3116 return "VK_COMPONENT_SWIZZLE_ZERO";
3117 default:
3118 return "Unhandled VkComponentSwizzle";
3119 }
3120 }
3121
string_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits input_value)3122 static inline const char* string_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits input_value)
3123 {
3124 switch (input_value)
3125 {
3126 case VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT:
3127 return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT";
3128 case VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT:
3129 return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT";
3130 default:
3131 return "Unhandled VkImageViewCreateFlagBits";
3132 }
3133 }
3134
string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value)3135 static inline std::string string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value)
3136 {
3137 std::string ret;
3138 int index = 0;
3139 while(input_value) {
3140 if (input_value & 1) {
3141 if( !ret.empty()) ret.append("|");
3142 ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(1U << index)));
3143 }
3144 ++index;
3145 input_value >>= 1;
3146 }
3147 if( ret.empty()) ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(0)));
3148 return ret;
3149 }
3150
string_VkImageViewType(VkImageViewType input_value)3151 static inline const char* string_VkImageViewType(VkImageViewType input_value)
3152 {
3153 switch (input_value)
3154 {
3155 case VK_IMAGE_VIEW_TYPE_1D:
3156 return "VK_IMAGE_VIEW_TYPE_1D";
3157 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
3158 return "VK_IMAGE_VIEW_TYPE_1D_ARRAY";
3159 case VK_IMAGE_VIEW_TYPE_2D:
3160 return "VK_IMAGE_VIEW_TYPE_2D";
3161 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
3162 return "VK_IMAGE_VIEW_TYPE_2D_ARRAY";
3163 case VK_IMAGE_VIEW_TYPE_3D:
3164 return "VK_IMAGE_VIEW_TYPE_3D";
3165 case VK_IMAGE_VIEW_TYPE_CUBE:
3166 return "VK_IMAGE_VIEW_TYPE_CUBE";
3167 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
3168 return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY";
3169 default:
3170 return "Unhandled VkImageViewType";
3171 }
3172 }
3173
string_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits input_value)3174 static inline const char* string_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits input_value)
3175 {
3176 switch (input_value)
3177 {
3178 case VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT:
3179 return "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT";
3180 default:
3181 return "Unhandled VkPipelineCacheCreateFlagBits";
3182 }
3183 }
3184
string_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags input_value)3185 static inline std::string string_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags input_value)
3186 {
3187 std::string ret;
3188 int index = 0;
3189 while(input_value) {
3190 if (input_value & 1) {
3191 if( !ret.empty()) ret.append("|");
3192 ret.append(string_VkPipelineCacheCreateFlagBits(static_cast<VkPipelineCacheCreateFlagBits>(1U << index)));
3193 }
3194 ++index;
3195 input_value >>= 1;
3196 }
3197 if( ret.empty()) ret.append(string_VkPipelineCacheCreateFlagBits(static_cast<VkPipelineCacheCreateFlagBits>(0)));
3198 return ret;
3199 }
3200
string_VkBlendFactor(VkBlendFactor input_value)3201 static inline const char* string_VkBlendFactor(VkBlendFactor input_value)
3202 {
3203 switch (input_value)
3204 {
3205 case VK_BLEND_FACTOR_CONSTANT_ALPHA:
3206 return "VK_BLEND_FACTOR_CONSTANT_ALPHA";
3207 case VK_BLEND_FACTOR_CONSTANT_COLOR:
3208 return "VK_BLEND_FACTOR_CONSTANT_COLOR";
3209 case VK_BLEND_FACTOR_DST_ALPHA:
3210 return "VK_BLEND_FACTOR_DST_ALPHA";
3211 case VK_BLEND_FACTOR_DST_COLOR:
3212 return "VK_BLEND_FACTOR_DST_COLOR";
3213 case VK_BLEND_FACTOR_ONE:
3214 return "VK_BLEND_FACTOR_ONE";
3215 case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
3216 return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA";
3217 case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
3218 return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR";
3219 case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
3220 return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA";
3221 case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
3222 return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR";
3223 case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
3224 return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA";
3225 case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
3226 return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR";
3227 case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
3228 return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA";
3229 case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
3230 return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR";
3231 case VK_BLEND_FACTOR_SRC1_ALPHA:
3232 return "VK_BLEND_FACTOR_SRC1_ALPHA";
3233 case VK_BLEND_FACTOR_SRC1_COLOR:
3234 return "VK_BLEND_FACTOR_SRC1_COLOR";
3235 case VK_BLEND_FACTOR_SRC_ALPHA:
3236 return "VK_BLEND_FACTOR_SRC_ALPHA";
3237 case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
3238 return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE";
3239 case VK_BLEND_FACTOR_SRC_COLOR:
3240 return "VK_BLEND_FACTOR_SRC_COLOR";
3241 case VK_BLEND_FACTOR_ZERO:
3242 return "VK_BLEND_FACTOR_ZERO";
3243 default:
3244 return "Unhandled VkBlendFactor";
3245 }
3246 }
3247
string_VkBlendOp(VkBlendOp input_value)3248 static inline const char* string_VkBlendOp(VkBlendOp input_value)
3249 {
3250 switch (input_value)
3251 {
3252 case VK_BLEND_OP_ADD:
3253 return "VK_BLEND_OP_ADD";
3254 case VK_BLEND_OP_BLUE_EXT:
3255 return "VK_BLEND_OP_BLUE_EXT";
3256 case VK_BLEND_OP_COLORBURN_EXT:
3257 return "VK_BLEND_OP_COLORBURN_EXT";
3258 case VK_BLEND_OP_COLORDODGE_EXT:
3259 return "VK_BLEND_OP_COLORDODGE_EXT";
3260 case VK_BLEND_OP_CONTRAST_EXT:
3261 return "VK_BLEND_OP_CONTRAST_EXT";
3262 case VK_BLEND_OP_DARKEN_EXT:
3263 return "VK_BLEND_OP_DARKEN_EXT";
3264 case VK_BLEND_OP_DIFFERENCE_EXT:
3265 return "VK_BLEND_OP_DIFFERENCE_EXT";
3266 case VK_BLEND_OP_DST_ATOP_EXT:
3267 return "VK_BLEND_OP_DST_ATOP_EXT";
3268 case VK_BLEND_OP_DST_EXT:
3269 return "VK_BLEND_OP_DST_EXT";
3270 case VK_BLEND_OP_DST_IN_EXT:
3271 return "VK_BLEND_OP_DST_IN_EXT";
3272 case VK_BLEND_OP_DST_OUT_EXT:
3273 return "VK_BLEND_OP_DST_OUT_EXT";
3274 case VK_BLEND_OP_DST_OVER_EXT:
3275 return "VK_BLEND_OP_DST_OVER_EXT";
3276 case VK_BLEND_OP_EXCLUSION_EXT:
3277 return "VK_BLEND_OP_EXCLUSION_EXT";
3278 case VK_BLEND_OP_GREEN_EXT:
3279 return "VK_BLEND_OP_GREEN_EXT";
3280 case VK_BLEND_OP_HARDLIGHT_EXT:
3281 return "VK_BLEND_OP_HARDLIGHT_EXT";
3282 case VK_BLEND_OP_HARDMIX_EXT:
3283 return "VK_BLEND_OP_HARDMIX_EXT";
3284 case VK_BLEND_OP_HSL_COLOR_EXT:
3285 return "VK_BLEND_OP_HSL_COLOR_EXT";
3286 case VK_BLEND_OP_HSL_HUE_EXT:
3287 return "VK_BLEND_OP_HSL_HUE_EXT";
3288 case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
3289 return "VK_BLEND_OP_HSL_LUMINOSITY_EXT";
3290 case VK_BLEND_OP_HSL_SATURATION_EXT:
3291 return "VK_BLEND_OP_HSL_SATURATION_EXT";
3292 case VK_BLEND_OP_INVERT_EXT:
3293 return "VK_BLEND_OP_INVERT_EXT";
3294 case VK_BLEND_OP_INVERT_OVG_EXT:
3295 return "VK_BLEND_OP_INVERT_OVG_EXT";
3296 case VK_BLEND_OP_INVERT_RGB_EXT:
3297 return "VK_BLEND_OP_INVERT_RGB_EXT";
3298 case VK_BLEND_OP_LIGHTEN_EXT:
3299 return "VK_BLEND_OP_LIGHTEN_EXT";
3300 case VK_BLEND_OP_LINEARBURN_EXT:
3301 return "VK_BLEND_OP_LINEARBURN_EXT";
3302 case VK_BLEND_OP_LINEARDODGE_EXT:
3303 return "VK_BLEND_OP_LINEARDODGE_EXT";
3304 case VK_BLEND_OP_LINEARLIGHT_EXT:
3305 return "VK_BLEND_OP_LINEARLIGHT_EXT";
3306 case VK_BLEND_OP_MAX:
3307 return "VK_BLEND_OP_MAX";
3308 case VK_BLEND_OP_MIN:
3309 return "VK_BLEND_OP_MIN";
3310 case VK_BLEND_OP_MINUS_CLAMPED_EXT:
3311 return "VK_BLEND_OP_MINUS_CLAMPED_EXT";
3312 case VK_BLEND_OP_MINUS_EXT:
3313 return "VK_BLEND_OP_MINUS_EXT";
3314 case VK_BLEND_OP_MULTIPLY_EXT:
3315 return "VK_BLEND_OP_MULTIPLY_EXT";
3316 case VK_BLEND_OP_OVERLAY_EXT:
3317 return "VK_BLEND_OP_OVERLAY_EXT";
3318 case VK_BLEND_OP_PINLIGHT_EXT:
3319 return "VK_BLEND_OP_PINLIGHT_EXT";
3320 case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT:
3321 return "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT";
3322 case VK_BLEND_OP_PLUS_CLAMPED_EXT:
3323 return "VK_BLEND_OP_PLUS_CLAMPED_EXT";
3324 case VK_BLEND_OP_PLUS_DARKER_EXT:
3325 return "VK_BLEND_OP_PLUS_DARKER_EXT";
3326 case VK_BLEND_OP_PLUS_EXT:
3327 return "VK_BLEND_OP_PLUS_EXT";
3328 case VK_BLEND_OP_RED_EXT:
3329 return "VK_BLEND_OP_RED_EXT";
3330 case VK_BLEND_OP_REVERSE_SUBTRACT:
3331 return "VK_BLEND_OP_REVERSE_SUBTRACT";
3332 case VK_BLEND_OP_SCREEN_EXT:
3333 return "VK_BLEND_OP_SCREEN_EXT";
3334 case VK_BLEND_OP_SOFTLIGHT_EXT:
3335 return "VK_BLEND_OP_SOFTLIGHT_EXT";
3336 case VK_BLEND_OP_SRC_ATOP_EXT:
3337 return "VK_BLEND_OP_SRC_ATOP_EXT";
3338 case VK_BLEND_OP_SRC_EXT:
3339 return "VK_BLEND_OP_SRC_EXT";
3340 case VK_BLEND_OP_SRC_IN_EXT:
3341 return "VK_BLEND_OP_SRC_IN_EXT";
3342 case VK_BLEND_OP_SRC_OUT_EXT:
3343 return "VK_BLEND_OP_SRC_OUT_EXT";
3344 case VK_BLEND_OP_SRC_OVER_EXT:
3345 return "VK_BLEND_OP_SRC_OVER_EXT";
3346 case VK_BLEND_OP_SUBTRACT:
3347 return "VK_BLEND_OP_SUBTRACT";
3348 case VK_BLEND_OP_VIVIDLIGHT_EXT:
3349 return "VK_BLEND_OP_VIVIDLIGHT_EXT";
3350 case VK_BLEND_OP_XOR_EXT:
3351 return "VK_BLEND_OP_XOR_EXT";
3352 case VK_BLEND_OP_ZERO_EXT:
3353 return "VK_BLEND_OP_ZERO_EXT";
3354 default:
3355 return "Unhandled VkBlendOp";
3356 }
3357 }
3358
string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)3359 static inline const char* string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)
3360 {
3361 switch (input_value)
3362 {
3363 case VK_COLOR_COMPONENT_A_BIT:
3364 return "VK_COLOR_COMPONENT_A_BIT";
3365 case VK_COLOR_COMPONENT_B_BIT:
3366 return "VK_COLOR_COMPONENT_B_BIT";
3367 case VK_COLOR_COMPONENT_G_BIT:
3368 return "VK_COLOR_COMPONENT_G_BIT";
3369 case VK_COLOR_COMPONENT_R_BIT:
3370 return "VK_COLOR_COMPONENT_R_BIT";
3371 default:
3372 return "Unhandled VkColorComponentFlagBits";
3373 }
3374 }
3375
string_VkColorComponentFlags(VkColorComponentFlags input_value)3376 static inline std::string string_VkColorComponentFlags(VkColorComponentFlags input_value)
3377 {
3378 std::string ret;
3379 int index = 0;
3380 while(input_value) {
3381 if (input_value & 1) {
3382 if( !ret.empty()) ret.append("|");
3383 ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(1U << index)));
3384 }
3385 ++index;
3386 input_value >>= 1;
3387 }
3388 if( ret.empty()) ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(0)));
3389 return ret;
3390 }
3391
string_VkCompareOp(VkCompareOp input_value)3392 static inline const char* string_VkCompareOp(VkCompareOp input_value)
3393 {
3394 switch (input_value)
3395 {
3396 case VK_COMPARE_OP_ALWAYS:
3397 return "VK_COMPARE_OP_ALWAYS";
3398 case VK_COMPARE_OP_EQUAL:
3399 return "VK_COMPARE_OP_EQUAL";
3400 case VK_COMPARE_OP_GREATER:
3401 return "VK_COMPARE_OP_GREATER";
3402 case VK_COMPARE_OP_GREATER_OR_EQUAL:
3403 return "VK_COMPARE_OP_GREATER_OR_EQUAL";
3404 case VK_COMPARE_OP_LESS:
3405 return "VK_COMPARE_OP_LESS";
3406 case VK_COMPARE_OP_LESS_OR_EQUAL:
3407 return "VK_COMPARE_OP_LESS_OR_EQUAL";
3408 case VK_COMPARE_OP_NEVER:
3409 return "VK_COMPARE_OP_NEVER";
3410 case VK_COMPARE_OP_NOT_EQUAL:
3411 return "VK_COMPARE_OP_NOT_EQUAL";
3412 default:
3413 return "Unhandled VkCompareOp";
3414 }
3415 }
3416
string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)3417 static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)
3418 {
3419 switch (input_value)
3420 {
3421 case VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT:
3422 return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
3423 case VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR:
3424 return "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
3425 case VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR:
3426 return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
3427 case VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV:
3428 return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
3429 case VK_PIPELINE_CREATE_DERIVATIVE_BIT:
3430 return "VK_PIPELINE_CREATE_DERIVATIVE_BIT";
3431 case VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
3432 return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
3433 case VK_PIPELINE_CREATE_DISPATCH_BASE_BIT:
3434 return "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT";
3435 case VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT:
3436 return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT";
3437 case VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT:
3438 return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT";
3439 case VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV:
3440 return "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV";
3441 case VK_PIPELINE_CREATE_LIBRARY_BIT_KHR:
3442 return "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR";
3443 case VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV:
3444 return "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV";
3445 case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR:
3446 return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
3447 case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR:
3448 return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
3449 case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR:
3450 return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
3451 case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR:
3452 return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
3453 case VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR:
3454 return "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
3455 case VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR:
3456 return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR";
3457 case VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR:
3458 return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
3459 case VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT:
3460 return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
3461 default:
3462 return "Unhandled VkPipelineCreateFlagBits";
3463 }
3464 }
3465
string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value)3466 static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value)
3467 {
3468 std::string ret;
3469 int index = 0;
3470 while(input_value) {
3471 if (input_value & 1) {
3472 if( !ret.empty()) ret.append("|");
3473 ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(1U << index)));
3474 }
3475 ++index;
3476 input_value >>= 1;
3477 }
3478 if( ret.empty()) ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(0)));
3479 return ret;
3480 }
3481
string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)3482 static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)
3483 {
3484 switch (input_value)
3485 {
3486 case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT:
3487 return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT";
3488 case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT:
3489 return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT";
3490 default:
3491 return "Unhandled VkPipelineShaderStageCreateFlagBits";
3492 }
3493 }
3494
string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)3495 static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)
3496 {
3497 std::string ret;
3498 int index = 0;
3499 while(input_value) {
3500 if (input_value & 1) {
3501 if( !ret.empty()) ret.append("|");
3502 ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1U << index)));
3503 }
3504 ++index;
3505 input_value >>= 1;
3506 }
3507 if( ret.empty()) ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(0)));
3508 return ret;
3509 }
3510
string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)3511 static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)
3512 {
3513 switch (input_value)
3514 {
3515 case VK_SHADER_STAGE_ALL:
3516 return "VK_SHADER_STAGE_ALL";
3517 case VK_SHADER_STAGE_ALL_GRAPHICS:
3518 return "VK_SHADER_STAGE_ALL_GRAPHICS";
3519 case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
3520 return "VK_SHADER_STAGE_ANY_HIT_BIT_KHR";
3521 case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
3522 return "VK_SHADER_STAGE_CALLABLE_BIT_KHR";
3523 case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
3524 return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR";
3525 case VK_SHADER_STAGE_COMPUTE_BIT:
3526 return "VK_SHADER_STAGE_COMPUTE_BIT";
3527 case VK_SHADER_STAGE_FRAGMENT_BIT:
3528 return "VK_SHADER_STAGE_FRAGMENT_BIT";
3529 case VK_SHADER_STAGE_GEOMETRY_BIT:
3530 return "VK_SHADER_STAGE_GEOMETRY_BIT";
3531 case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
3532 return "VK_SHADER_STAGE_INTERSECTION_BIT_KHR";
3533 case VK_SHADER_STAGE_MESH_BIT_NV:
3534 return "VK_SHADER_STAGE_MESH_BIT_NV";
3535 case VK_SHADER_STAGE_MISS_BIT_KHR:
3536 return "VK_SHADER_STAGE_MISS_BIT_KHR";
3537 case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
3538 return "VK_SHADER_STAGE_RAYGEN_BIT_KHR";
3539 case VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI:
3540 return "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI";
3541 case VK_SHADER_STAGE_TASK_BIT_NV:
3542 return "VK_SHADER_STAGE_TASK_BIT_NV";
3543 case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
3544 return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
3545 case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
3546 return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
3547 case VK_SHADER_STAGE_VERTEX_BIT:
3548 return "VK_SHADER_STAGE_VERTEX_BIT";
3549 default:
3550 return "Unhandled VkShaderStageFlagBits";
3551 }
3552 }
3553
string_VkShaderStageFlags(VkShaderStageFlags input_value)3554 static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_value)
3555 {
3556 std::string ret;
3557 int index = 0;
3558 while(input_value) {
3559 if (input_value & 1) {
3560 if( !ret.empty()) ret.append("|");
3561 ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(1U << index)));
3562 }
3563 ++index;
3564 input_value >>= 1;
3565 }
3566 if( ret.empty()) ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(0)));
3567 return ret;
3568 }
3569
string_VkCullModeFlagBits(VkCullModeFlagBits input_value)3570 static inline const char* string_VkCullModeFlagBits(VkCullModeFlagBits input_value)
3571 {
3572 switch (input_value)
3573 {
3574 case VK_CULL_MODE_BACK_BIT:
3575 return "VK_CULL_MODE_BACK_BIT";
3576 case VK_CULL_MODE_FRONT_AND_BACK:
3577 return "VK_CULL_MODE_FRONT_AND_BACK";
3578 case VK_CULL_MODE_FRONT_BIT:
3579 return "VK_CULL_MODE_FRONT_BIT";
3580 case VK_CULL_MODE_NONE:
3581 return "VK_CULL_MODE_NONE";
3582 default:
3583 return "Unhandled VkCullModeFlagBits";
3584 }
3585 }
3586
string_VkCullModeFlags(VkCullModeFlags input_value)3587 static inline std::string string_VkCullModeFlags(VkCullModeFlags input_value)
3588 {
3589 std::string ret;
3590 int index = 0;
3591 while(input_value) {
3592 if (input_value & 1) {
3593 if( !ret.empty()) ret.append("|");
3594 ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(1U << index)));
3595 }
3596 ++index;
3597 input_value >>= 1;
3598 }
3599 if( ret.empty()) ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(0)));
3600 return ret;
3601 }
3602
string_VkDynamicState(VkDynamicState input_value)3603 static inline const char* string_VkDynamicState(VkDynamicState input_value)
3604 {
3605 switch (input_value)
3606 {
3607 case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
3608 return "VK_DYNAMIC_STATE_BLEND_CONSTANTS";
3609 case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
3610 return "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT";
3611 case VK_DYNAMIC_STATE_CULL_MODE_EXT:
3612 return "VK_DYNAMIC_STATE_CULL_MODE_EXT";
3613 case VK_DYNAMIC_STATE_DEPTH_BIAS:
3614 return "VK_DYNAMIC_STATE_DEPTH_BIAS";
3615 case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT:
3616 return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT";
3617 case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
3618 return "VK_DYNAMIC_STATE_DEPTH_BOUNDS";
3619 case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT:
3620 return "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT";
3621 case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT:
3622 return "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT";
3623 case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT:
3624 return "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT";
3625 case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT:
3626 return "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT";
3627 case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
3628 return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT";
3629 case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
3630 return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
3631 case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
3632 return "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR";
3633 case VK_DYNAMIC_STATE_FRONT_FACE_EXT:
3634 return "VK_DYNAMIC_STATE_FRONT_FACE_EXT";
3635 case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
3636 return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
3637 case VK_DYNAMIC_STATE_LINE_WIDTH:
3638 return "VK_DYNAMIC_STATE_LINE_WIDTH";
3639 case VK_DYNAMIC_STATE_LOGIC_OP_EXT:
3640 return "VK_DYNAMIC_STATE_LOGIC_OP_EXT";
3641 case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
3642 return "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT";
3643 case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT:
3644 return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT";
3645 case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT:
3646 return "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT";
3647 case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT:
3648 return "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT";
3649 case VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR:
3650 return "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR";
3651 case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
3652 return "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT";
3653 case VK_DYNAMIC_STATE_SCISSOR:
3654 return "VK_DYNAMIC_STATE_SCISSOR";
3655 case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT:
3656 return "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT";
3657 case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
3658 return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK";
3659 case VK_DYNAMIC_STATE_STENCIL_OP_EXT:
3660 return "VK_DYNAMIC_STATE_STENCIL_OP_EXT";
3661 case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
3662 return "VK_DYNAMIC_STATE_STENCIL_REFERENCE";
3663 case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT:
3664 return "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT";
3665 case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
3666 return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK";
3667 case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT:
3668 return "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT";
3669 case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
3670 return "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT";
3671 case VK_DYNAMIC_STATE_VIEWPORT:
3672 return "VK_DYNAMIC_STATE_VIEWPORT";
3673 case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
3674 return "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV";
3675 case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
3676 return "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV";
3677 case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT:
3678 return "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT";
3679 case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
3680 return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV";
3681 default:
3682 return "Unhandled VkDynamicState";
3683 }
3684 }
3685
string_VkFrontFace(VkFrontFace input_value)3686 static inline const char* string_VkFrontFace(VkFrontFace input_value)
3687 {
3688 switch (input_value)
3689 {
3690 case VK_FRONT_FACE_CLOCKWISE:
3691 return "VK_FRONT_FACE_CLOCKWISE";
3692 case VK_FRONT_FACE_COUNTER_CLOCKWISE:
3693 return "VK_FRONT_FACE_COUNTER_CLOCKWISE";
3694 default:
3695 return "Unhandled VkFrontFace";
3696 }
3697 }
3698
string_VkVertexInputRate(VkVertexInputRate input_value)3699 static inline const char* string_VkVertexInputRate(VkVertexInputRate input_value)
3700 {
3701 switch (input_value)
3702 {
3703 case VK_VERTEX_INPUT_RATE_INSTANCE:
3704 return "VK_VERTEX_INPUT_RATE_INSTANCE";
3705 case VK_VERTEX_INPUT_RATE_VERTEX:
3706 return "VK_VERTEX_INPUT_RATE_VERTEX";
3707 default:
3708 return "Unhandled VkVertexInputRate";
3709 }
3710 }
3711
string_VkPrimitiveTopology(VkPrimitiveTopology input_value)3712 static inline const char* string_VkPrimitiveTopology(VkPrimitiveTopology input_value)
3713 {
3714 switch (input_value)
3715 {
3716 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
3717 return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST";
3718 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
3719 return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY";
3720 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
3721 return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP";
3722 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
3723 return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY";
3724 case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
3725 return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST";
3726 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
3727 return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST";
3728 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
3729 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN";
3730 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
3731 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST";
3732 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
3733 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY";
3734 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
3735 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP";
3736 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
3737 return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY";
3738 default:
3739 return "Unhandled VkPrimitiveTopology";
3740 }
3741 }
3742
string_VkPolygonMode(VkPolygonMode input_value)3743 static inline const char* string_VkPolygonMode(VkPolygonMode input_value)
3744 {
3745 switch (input_value)
3746 {
3747 case VK_POLYGON_MODE_FILL:
3748 return "VK_POLYGON_MODE_FILL";
3749 case VK_POLYGON_MODE_FILL_RECTANGLE_NV:
3750 return "VK_POLYGON_MODE_FILL_RECTANGLE_NV";
3751 case VK_POLYGON_MODE_LINE:
3752 return "VK_POLYGON_MODE_LINE";
3753 case VK_POLYGON_MODE_POINT:
3754 return "VK_POLYGON_MODE_POINT";
3755 default:
3756 return "Unhandled VkPolygonMode";
3757 }
3758 }
3759
string_VkStencilOp(VkStencilOp input_value)3760 static inline const char* string_VkStencilOp(VkStencilOp input_value)
3761 {
3762 switch (input_value)
3763 {
3764 case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
3765 return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
3766 case VK_STENCIL_OP_DECREMENT_AND_WRAP:
3767 return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
3768 case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
3769 return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
3770 case VK_STENCIL_OP_INCREMENT_AND_WRAP:
3771 return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
3772 case VK_STENCIL_OP_INVERT:
3773 return "VK_STENCIL_OP_INVERT";
3774 case VK_STENCIL_OP_KEEP:
3775 return "VK_STENCIL_OP_KEEP";
3776 case VK_STENCIL_OP_REPLACE:
3777 return "VK_STENCIL_OP_REPLACE";
3778 case VK_STENCIL_OP_ZERO:
3779 return "VK_STENCIL_OP_ZERO";
3780 default:
3781 return "Unhandled VkStencilOp";
3782 }
3783 }
3784
string_VkLogicOp(VkLogicOp input_value)3785 static inline const char* string_VkLogicOp(VkLogicOp input_value)
3786 {
3787 switch (input_value)
3788 {
3789 case VK_LOGIC_OP_AND:
3790 return "VK_LOGIC_OP_AND";
3791 case VK_LOGIC_OP_AND_INVERTED:
3792 return "VK_LOGIC_OP_AND_INVERTED";
3793 case VK_LOGIC_OP_AND_REVERSE:
3794 return "VK_LOGIC_OP_AND_REVERSE";
3795 case VK_LOGIC_OP_CLEAR:
3796 return "VK_LOGIC_OP_CLEAR";
3797 case VK_LOGIC_OP_COPY:
3798 return "VK_LOGIC_OP_COPY";
3799 case VK_LOGIC_OP_COPY_INVERTED:
3800 return "VK_LOGIC_OP_COPY_INVERTED";
3801 case VK_LOGIC_OP_EQUIVALENT:
3802 return "VK_LOGIC_OP_EQUIVALENT";
3803 case VK_LOGIC_OP_INVERT:
3804 return "VK_LOGIC_OP_INVERT";
3805 case VK_LOGIC_OP_NAND:
3806 return "VK_LOGIC_OP_NAND";
3807 case VK_LOGIC_OP_NOR:
3808 return "VK_LOGIC_OP_NOR";
3809 case VK_LOGIC_OP_NO_OP:
3810 return "VK_LOGIC_OP_NO_OP";
3811 case VK_LOGIC_OP_OR:
3812 return "VK_LOGIC_OP_OR";
3813 case VK_LOGIC_OP_OR_INVERTED:
3814 return "VK_LOGIC_OP_OR_INVERTED";
3815 case VK_LOGIC_OP_OR_REVERSE:
3816 return "VK_LOGIC_OP_OR_REVERSE";
3817 case VK_LOGIC_OP_SET:
3818 return "VK_LOGIC_OP_SET";
3819 case VK_LOGIC_OP_XOR:
3820 return "VK_LOGIC_OP_XOR";
3821 default:
3822 return "Unhandled VkLogicOp";
3823 }
3824 }
3825
string_VkBorderColor(VkBorderColor input_value)3826 static inline const char* string_VkBorderColor(VkBorderColor input_value)
3827 {
3828 switch (input_value)
3829 {
3830 case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
3831 return "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT";
3832 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
3833 return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK";
3834 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
3835 return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE";
3836 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
3837 return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK";
3838 case VK_BORDER_COLOR_INT_CUSTOM_EXT:
3839 return "VK_BORDER_COLOR_INT_CUSTOM_EXT";
3840 case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
3841 return "VK_BORDER_COLOR_INT_OPAQUE_BLACK";
3842 case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
3843 return "VK_BORDER_COLOR_INT_OPAQUE_WHITE";
3844 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
3845 return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK";
3846 default:
3847 return "Unhandled VkBorderColor";
3848 }
3849 }
3850
string_VkFilter(VkFilter input_value)3851 static inline const char* string_VkFilter(VkFilter input_value)
3852 {
3853 switch (input_value)
3854 {
3855 case VK_FILTER_CUBIC_IMG:
3856 return "VK_FILTER_CUBIC_IMG";
3857 case VK_FILTER_LINEAR:
3858 return "VK_FILTER_LINEAR";
3859 case VK_FILTER_NEAREST:
3860 return "VK_FILTER_NEAREST";
3861 default:
3862 return "Unhandled VkFilter";
3863 }
3864 }
3865
string_VkSamplerAddressMode(VkSamplerAddressMode input_value)3866 static inline const char* string_VkSamplerAddressMode(VkSamplerAddressMode input_value)
3867 {
3868 switch (input_value)
3869 {
3870 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
3871 return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER";
3872 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
3873 return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE";
3874 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
3875 return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT";
3876 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
3877 return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE";
3878 case VK_SAMPLER_ADDRESS_MODE_REPEAT:
3879 return "VK_SAMPLER_ADDRESS_MODE_REPEAT";
3880 default:
3881 return "Unhandled VkSamplerAddressMode";
3882 }
3883 }
3884
string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits input_value)3885 static inline const char* string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits input_value)
3886 {
3887 switch (input_value)
3888 {
3889 case VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT:
3890 return "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT";
3891 case VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT:
3892 return "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT";
3893 default:
3894 return "Unhandled VkSamplerCreateFlagBits";
3895 }
3896 }
3897
string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value)3898 static inline std::string string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value)
3899 {
3900 std::string ret;
3901 int index = 0;
3902 while(input_value) {
3903 if (input_value & 1) {
3904 if( !ret.empty()) ret.append("|");
3905 ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(1U << index)));
3906 }
3907 ++index;
3908 input_value >>= 1;
3909 }
3910 if( ret.empty()) ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(0)));
3911 return ret;
3912 }
3913
string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)3914 static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)
3915 {
3916 switch (input_value)
3917 {
3918 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
3919 return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
3920 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
3921 return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
3922 default:
3923 return "Unhandled VkSamplerMipmapMode";
3924 }
3925 }
3926
string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)3927 static inline const char* string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)
3928 {
3929 switch (input_value)
3930 {
3931 case VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT:
3932 return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT";
3933 case VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE:
3934 return "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE";
3935 case VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT:
3936 return "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT";
3937 default:
3938 return "Unhandled VkDescriptorPoolCreateFlagBits";
3939 }
3940 }
3941
string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value)3942 static inline std::string string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value)
3943 {
3944 std::string ret;
3945 int index = 0;
3946 while(input_value) {
3947 if (input_value & 1) {
3948 if( !ret.empty()) ret.append("|");
3949 ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(1U << index)));
3950 }
3951 ++index;
3952 input_value >>= 1;
3953 }
3954 if( ret.empty()) ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(0)));
3955 return ret;
3956 }
3957
string_VkDescriptorType(VkDescriptorType input_value)3958 static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
3959 {
3960 switch (input_value)
3961 {
3962 case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
3963 return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR";
3964 case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
3965 return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV";
3966 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3967 return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
3968 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
3969 return "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT";
3970 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3971 return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT";
3972 case VK_DESCRIPTOR_TYPE_MUTABLE_VALVE:
3973 return "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE";
3974 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3975 return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
3976 case VK_DESCRIPTOR_TYPE_SAMPLER:
3977 return "VK_DESCRIPTOR_TYPE_SAMPLER";
3978 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3979 return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
3980 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3981 return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
3982 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3983 return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
3984 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3985 return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
3986 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3987 return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
3988 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3989 return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
3990 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3991 return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
3992 default:
3993 return "Unhandled VkDescriptorType";
3994 }
3995 }
3996
string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)3997 static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)
3998 {
3999 switch (input_value)
4000 {
4001 case VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE:
4002 return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE";
4003 case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR:
4004 return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR";
4005 case VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT:
4006 return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT";
4007 default:
4008 return "Unhandled VkDescriptorSetLayoutCreateFlagBits";
4009 }
4010 }
4011
string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value)4012 static inline std::string string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value)
4013 {
4014 std::string ret;
4015 int index = 0;
4016 while(input_value) {
4017 if (input_value & 1) {
4018 if( !ret.empty()) ret.append("|");
4019 ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(1U << index)));
4020 }
4021 ++index;
4022 input_value >>= 1;
4023 }
4024 if( ret.empty()) ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(0)));
4025 return ret;
4026 }
4027
string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)4028 static inline const char* string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)
4029 {
4030 switch (input_value)
4031 {
4032 case VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT:
4033 return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT";
4034 default:
4035 return "Unhandled VkAttachmentDescriptionFlagBits";
4036 }
4037 }
4038
string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value)4039 static inline std::string string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value)
4040 {
4041 std::string ret;
4042 int index = 0;
4043 while(input_value) {
4044 if (input_value & 1) {
4045 if( !ret.empty()) ret.append("|");
4046 ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(1U << index)));
4047 }
4048 ++index;
4049 input_value >>= 1;
4050 }
4051 if( ret.empty()) ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(0)));
4052 return ret;
4053 }
4054
string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)4055 static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)
4056 {
4057 switch (input_value)
4058 {
4059 case VK_ATTACHMENT_LOAD_OP_CLEAR:
4060 return "VK_ATTACHMENT_LOAD_OP_CLEAR";
4061 case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
4062 return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
4063 case VK_ATTACHMENT_LOAD_OP_LOAD:
4064 return "VK_ATTACHMENT_LOAD_OP_LOAD";
4065 default:
4066 return "Unhandled VkAttachmentLoadOp";
4067 }
4068 }
4069
string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)4070 static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)
4071 {
4072 switch (input_value)
4073 {
4074 case VK_ATTACHMENT_STORE_OP_DONT_CARE:
4075 return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
4076 case VK_ATTACHMENT_STORE_OP_NONE_QCOM:
4077 return "VK_ATTACHMENT_STORE_OP_NONE_QCOM";
4078 case VK_ATTACHMENT_STORE_OP_STORE:
4079 return "VK_ATTACHMENT_STORE_OP_STORE";
4080 default:
4081 return "Unhandled VkAttachmentStoreOp";
4082 }
4083 }
4084
string_VkDependencyFlagBits(VkDependencyFlagBits input_value)4085 static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input_value)
4086 {
4087 switch (input_value)
4088 {
4089 case VK_DEPENDENCY_BY_REGION_BIT:
4090 return "VK_DEPENDENCY_BY_REGION_BIT";
4091 case VK_DEPENDENCY_DEVICE_GROUP_BIT:
4092 return "VK_DEPENDENCY_DEVICE_GROUP_BIT";
4093 case VK_DEPENDENCY_VIEW_LOCAL_BIT:
4094 return "VK_DEPENDENCY_VIEW_LOCAL_BIT";
4095 default:
4096 return "Unhandled VkDependencyFlagBits";
4097 }
4098 }
4099
string_VkDependencyFlags(VkDependencyFlags input_value)4100 static inline std::string string_VkDependencyFlags(VkDependencyFlags input_value)
4101 {
4102 std::string ret;
4103 int index = 0;
4104 while(input_value) {
4105 if (input_value & 1) {
4106 if( !ret.empty()) ret.append("|");
4107 ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(1U << index)));
4108 }
4109 ++index;
4110 input_value >>= 1;
4111 }
4112 if( ret.empty()) ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(0)));
4113 return ret;
4114 }
4115
string_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits input_value)4116 static inline const char* string_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits input_value)
4117 {
4118 switch (input_value)
4119 {
4120 case VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT:
4121 return "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT";
4122 default:
4123 return "Unhandled VkFramebufferCreateFlagBits";
4124 }
4125 }
4126
string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value)4127 static inline std::string string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value)
4128 {
4129 std::string ret;
4130 int index = 0;
4131 while(input_value) {
4132 if (input_value & 1) {
4133 if( !ret.empty()) ret.append("|");
4134 ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(1U << index)));
4135 }
4136 ++index;
4137 input_value >>= 1;
4138 }
4139 if( ret.empty()) ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(0)));
4140 return ret;
4141 }
4142
string_VkPipelineBindPoint(VkPipelineBindPoint input_value)4143 static inline const char* string_VkPipelineBindPoint(VkPipelineBindPoint input_value)
4144 {
4145 switch (input_value)
4146 {
4147 case VK_PIPELINE_BIND_POINT_COMPUTE:
4148 return "VK_PIPELINE_BIND_POINT_COMPUTE";
4149 case VK_PIPELINE_BIND_POINT_GRAPHICS:
4150 return "VK_PIPELINE_BIND_POINT_GRAPHICS";
4151 case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR:
4152 return "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR";
4153 case VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI:
4154 return "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI";
4155 default:
4156 return "Unhandled VkPipelineBindPoint";
4157 }
4158 }
4159
string_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits input_value)4160 static inline const char* string_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits input_value)
4161 {
4162 switch (input_value)
4163 {
4164 case VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM:
4165 return "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM";
4166 default:
4167 return "Unhandled VkRenderPassCreateFlagBits";
4168 }
4169 }
4170
string_VkRenderPassCreateFlags(VkRenderPassCreateFlags input_value)4171 static inline std::string string_VkRenderPassCreateFlags(VkRenderPassCreateFlags input_value)
4172 {
4173 std::string ret;
4174 int index = 0;
4175 while(input_value) {
4176 if (input_value & 1) {
4177 if( !ret.empty()) ret.append("|");
4178 ret.append(string_VkRenderPassCreateFlagBits(static_cast<VkRenderPassCreateFlagBits>(1U << index)));
4179 }
4180 ++index;
4181 input_value >>= 1;
4182 }
4183 if( ret.empty()) ret.append(string_VkRenderPassCreateFlagBits(static_cast<VkRenderPassCreateFlagBits>(0)));
4184 return ret;
4185 }
4186
string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)4187 static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)
4188 {
4189 switch (input_value)
4190 {
4191 case VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM:
4192 return "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM";
4193 case VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX:
4194 return "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX";
4195 case VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX:
4196 return "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX";
4197 case VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM:
4198 return "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM";
4199 default:
4200 return "Unhandled VkSubpassDescriptionFlagBits";
4201 }
4202 }
4203
string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value)4204 static inline std::string string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value)
4205 {
4206 std::string ret;
4207 int index = 0;
4208 while(input_value) {
4209 if (input_value & 1) {
4210 if( !ret.empty()) ret.append("|");
4211 ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(1U << index)));
4212 }
4213 ++index;
4214 input_value >>= 1;
4215 }
4216 if( ret.empty()) ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(0)));
4217 return ret;
4218 }
4219
string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)4220 static inline const char* string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)
4221 {
4222 switch (input_value)
4223 {
4224 case VK_COMMAND_POOL_CREATE_PROTECTED_BIT:
4225 return "VK_COMMAND_POOL_CREATE_PROTECTED_BIT";
4226 case VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT:
4227 return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT";
4228 case VK_COMMAND_POOL_CREATE_TRANSIENT_BIT:
4229 return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT";
4230 default:
4231 return "Unhandled VkCommandPoolCreateFlagBits";
4232 }
4233 }
4234
string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value)4235 static inline std::string string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value)
4236 {
4237 std::string ret;
4238 int index = 0;
4239 while(input_value) {
4240 if (input_value & 1) {
4241 if( !ret.empty()) ret.append("|");
4242 ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(1U << index)));
4243 }
4244 ++index;
4245 input_value >>= 1;
4246 }
4247 if( ret.empty()) ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(0)));
4248 return ret;
4249 }
4250
string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)4251 static inline const char* string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)
4252 {
4253 switch (input_value)
4254 {
4255 case VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT:
4256 return "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT";
4257 default:
4258 return "Unhandled VkCommandPoolResetFlagBits";
4259 }
4260 }
4261
string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value)4262 static inline std::string string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value)
4263 {
4264 std::string ret;
4265 int index = 0;
4266 while(input_value) {
4267 if (input_value & 1) {
4268 if( !ret.empty()) ret.append("|");
4269 ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(1U << index)));
4270 }
4271 ++index;
4272 input_value >>= 1;
4273 }
4274 if( ret.empty()) ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(0)));
4275 return ret;
4276 }
4277
string_VkCommandBufferLevel(VkCommandBufferLevel input_value)4278 static inline const char* string_VkCommandBufferLevel(VkCommandBufferLevel input_value)
4279 {
4280 switch (input_value)
4281 {
4282 case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
4283 return "VK_COMMAND_BUFFER_LEVEL_PRIMARY";
4284 case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
4285 return "VK_COMMAND_BUFFER_LEVEL_SECONDARY";
4286 default:
4287 return "Unhandled VkCommandBufferLevel";
4288 }
4289 }
4290
string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)4291 static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)
4292 {
4293 switch (input_value)
4294 {
4295 case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
4296 return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
4297 case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
4298 return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
4299 case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
4300 return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
4301 default:
4302 return "Unhandled VkCommandBufferUsageFlagBits";
4303 }
4304 }
4305
string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value)4306 static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value)
4307 {
4308 std::string ret;
4309 int index = 0;
4310 while(input_value) {
4311 if (input_value & 1) {
4312 if( !ret.empty()) ret.append("|");
4313 ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(1U << index)));
4314 }
4315 ++index;
4316 input_value >>= 1;
4317 }
4318 if( ret.empty()) ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(0)));
4319 return ret;
4320 }
4321
string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)4322 static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)
4323 {
4324 switch (input_value)
4325 {
4326 case VK_QUERY_CONTROL_PRECISE_BIT:
4327 return "VK_QUERY_CONTROL_PRECISE_BIT";
4328 default:
4329 return "Unhandled VkQueryControlFlagBits";
4330 }
4331 }
4332
string_VkQueryControlFlags(VkQueryControlFlags input_value)4333 static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value)
4334 {
4335 std::string ret;
4336 int index = 0;
4337 while(input_value) {
4338 if (input_value & 1) {
4339 if( !ret.empty()) ret.append("|");
4340 ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(1U << index)));
4341 }
4342 ++index;
4343 input_value >>= 1;
4344 }
4345 if( ret.empty()) ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(0)));
4346 return ret;
4347 }
4348
string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)4349 static inline const char* string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)
4350 {
4351 switch (input_value)
4352 {
4353 case VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT:
4354 return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT";
4355 default:
4356 return "Unhandled VkCommandBufferResetFlagBits";
4357 }
4358 }
4359
string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value)4360 static inline std::string string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value)
4361 {
4362 std::string ret;
4363 int index = 0;
4364 while(input_value) {
4365 if (input_value & 1) {
4366 if( !ret.empty()) ret.append("|");
4367 ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(1U << index)));
4368 }
4369 ++index;
4370 input_value >>= 1;
4371 }
4372 if( ret.empty()) ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(0)));
4373 return ret;
4374 }
4375
string_VkIndexType(VkIndexType input_value)4376 static inline const char* string_VkIndexType(VkIndexType input_value)
4377 {
4378 switch (input_value)
4379 {
4380 case VK_INDEX_TYPE_NONE_KHR:
4381 return "VK_INDEX_TYPE_NONE_KHR";
4382 case VK_INDEX_TYPE_UINT16:
4383 return "VK_INDEX_TYPE_UINT16";
4384 case VK_INDEX_TYPE_UINT32:
4385 return "VK_INDEX_TYPE_UINT32";
4386 case VK_INDEX_TYPE_UINT8_EXT:
4387 return "VK_INDEX_TYPE_UINT8_EXT";
4388 default:
4389 return "Unhandled VkIndexType";
4390 }
4391 }
4392
string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)4393 static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)
4394 {
4395 switch (input_value)
4396 {
4397 case VK_STENCIL_FACE_BACK_BIT:
4398 return "VK_STENCIL_FACE_BACK_BIT";
4399 case VK_STENCIL_FACE_FRONT_AND_BACK:
4400 return "VK_STENCIL_FACE_FRONT_AND_BACK";
4401 case VK_STENCIL_FACE_FRONT_BIT:
4402 return "VK_STENCIL_FACE_FRONT_BIT";
4403 default:
4404 return "Unhandled VkStencilFaceFlagBits";
4405 }
4406 }
4407
string_VkStencilFaceFlags(VkStencilFaceFlags input_value)4408 static inline std::string string_VkStencilFaceFlags(VkStencilFaceFlags input_value)
4409 {
4410 std::string ret;
4411 int index = 0;
4412 while(input_value) {
4413 if (input_value & 1) {
4414 if( !ret.empty()) ret.append("|");
4415 ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(1U << index)));
4416 }
4417 ++index;
4418 input_value >>= 1;
4419 }
4420 if( ret.empty()) ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(0)));
4421 return ret;
4422 }
4423
string_VkSubpassContents(VkSubpassContents input_value)4424 static inline const char* string_VkSubpassContents(VkSubpassContents input_value)
4425 {
4426 switch (input_value)
4427 {
4428 case VK_SUBPASS_CONTENTS_INLINE:
4429 return "VK_SUBPASS_CONTENTS_INLINE";
4430 case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
4431 return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS";
4432 default:
4433 return "Unhandled VkSubpassContents";
4434 }
4435 }
4436
string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value)4437 static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value)
4438 {
4439 switch (input_value)
4440 {
4441 case VK_SUBGROUP_FEATURE_ARITHMETIC_BIT:
4442 return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
4443 case VK_SUBGROUP_FEATURE_BALLOT_BIT:
4444 return "VK_SUBGROUP_FEATURE_BALLOT_BIT";
4445 case VK_SUBGROUP_FEATURE_BASIC_BIT:
4446 return "VK_SUBGROUP_FEATURE_BASIC_BIT";
4447 case VK_SUBGROUP_FEATURE_CLUSTERED_BIT:
4448 return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
4449 case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
4450 return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
4451 case VK_SUBGROUP_FEATURE_QUAD_BIT:
4452 return "VK_SUBGROUP_FEATURE_QUAD_BIT";
4453 case VK_SUBGROUP_FEATURE_SHUFFLE_BIT:
4454 return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
4455 case VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT:
4456 return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
4457 case VK_SUBGROUP_FEATURE_VOTE_BIT:
4458 return "VK_SUBGROUP_FEATURE_VOTE_BIT";
4459 default:
4460 return "Unhandled VkSubgroupFeatureFlagBits";
4461 }
4462 }
4463
string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value)4464 static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value)
4465 {
4466 std::string ret;
4467 int index = 0;
4468 while(input_value) {
4469 if (input_value & 1) {
4470 if( !ret.empty()) ret.append("|");
4471 ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(1U << index)));
4472 }
4473 ++index;
4474 input_value >>= 1;
4475 }
4476 if( ret.empty()) ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(0)));
4477 return ret;
4478 }
4479
string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value)4480 static inline const char* string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value)
4481 {
4482 switch (input_value)
4483 {
4484 case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
4485 return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
4486 case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
4487 return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
4488 case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
4489 return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
4490 case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
4491 return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
4492 default:
4493 return "Unhandled VkPeerMemoryFeatureFlagBits";
4494 }
4495 }
4496
string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value)4497 static inline std::string string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value)
4498 {
4499 std::string ret;
4500 int index = 0;
4501 while(input_value) {
4502 if (input_value & 1) {
4503 if( !ret.empty()) ret.append("|");
4504 ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(1U << index)));
4505 }
4506 ++index;
4507 input_value >>= 1;
4508 }
4509 if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(0)));
4510 return ret;
4511 }
4512
string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits input_value)4513 static inline const char* string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits input_value)
4514 {
4515 switch (input_value)
4516 {
4517 case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT:
4518 return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
4519 case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
4520 return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
4521 case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
4522 return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
4523 default:
4524 return "Unhandled VkMemoryAllocateFlagBits";
4525 }
4526 }
4527
string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value)4528 static inline std::string string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value)
4529 {
4530 std::string ret;
4531 int index = 0;
4532 while(input_value) {
4533 if (input_value & 1) {
4534 if( !ret.empty()) ret.append("|");
4535 ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(1U << index)));
4536 }
4537 ++index;
4538 input_value >>= 1;
4539 }
4540 if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(0)));
4541 return ret;
4542 }
4543
string_VkPointClippingBehavior(VkPointClippingBehavior input_value)4544 static inline const char* string_VkPointClippingBehavior(VkPointClippingBehavior input_value)
4545 {
4546 switch (input_value)
4547 {
4548 case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
4549 return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
4550 case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
4551 return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
4552 default:
4553 return "Unhandled VkPointClippingBehavior";
4554 }
4555 }
4556
string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value)4557 static inline const char* string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value)
4558 {
4559 switch (input_value)
4560 {
4561 case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
4562 return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
4563 case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
4564 return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
4565 default:
4566 return "Unhandled VkTessellationDomainOrigin";
4567 }
4568 }
4569
string_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion input_value)4570 static inline const char* string_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion input_value)
4571 {
4572 switch (input_value)
4573 {
4574 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
4575 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
4576 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
4577 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
4578 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
4579 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
4580 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
4581 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
4582 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
4583 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
4584 default:
4585 return "Unhandled VkSamplerYcbcrModelConversion";
4586 }
4587 }
4588
string_VkSamplerYcbcrRange(VkSamplerYcbcrRange input_value)4589 static inline const char* string_VkSamplerYcbcrRange(VkSamplerYcbcrRange input_value)
4590 {
4591 switch (input_value)
4592 {
4593 case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
4594 return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
4595 case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
4596 return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
4597 default:
4598 return "Unhandled VkSamplerYcbcrRange";
4599 }
4600 }
4601
string_VkChromaLocation(VkChromaLocation input_value)4602 static inline const char* string_VkChromaLocation(VkChromaLocation input_value)
4603 {
4604 switch (input_value)
4605 {
4606 case VK_CHROMA_LOCATION_COSITED_EVEN:
4607 return "VK_CHROMA_LOCATION_COSITED_EVEN";
4608 case VK_CHROMA_LOCATION_MIDPOINT:
4609 return "VK_CHROMA_LOCATION_MIDPOINT";
4610 default:
4611 return "Unhandled VkChromaLocation";
4612 }
4613 }
4614
string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value)4615 static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value)
4616 {
4617 switch (input_value)
4618 {
4619 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
4620 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
4621 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
4622 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
4623 default:
4624 return "Unhandled VkDescriptorUpdateTemplateType";
4625 }
4626 }
4627
string_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits input_value)4628 static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits input_value)
4629 {
4630 switch (input_value)
4631 {
4632 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
4633 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
4634 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
4635 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
4636 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
4637 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
4638 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
4639 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
4640 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
4641 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
4642 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
4643 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
4644 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
4645 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
4646 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
4647 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
4648 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
4649 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
4650 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4651 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4652 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4653 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4654 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA:
4655 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA";
4656 default:
4657 return "Unhandled VkExternalMemoryHandleTypeFlagBits";
4658 }
4659 }
4660
string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value)4661 static inline std::string string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value)
4662 {
4663 std::string ret;
4664 int index = 0;
4665 while(input_value) {
4666 if (input_value & 1) {
4667 if( !ret.empty()) ret.append("|");
4668 ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(1U << index)));
4669 }
4670 ++index;
4671 input_value >>= 1;
4672 }
4673 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(0)));
4674 return ret;
4675 }
4676
string_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits input_value)4677 static inline const char* string_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits input_value)
4678 {
4679 switch (input_value)
4680 {
4681 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
4682 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
4683 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
4684 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
4685 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
4686 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
4687 default:
4688 return "Unhandled VkExternalMemoryFeatureFlagBits";
4689 }
4690 }
4691
string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value)4692 static inline std::string string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value)
4693 {
4694 std::string ret;
4695 int index = 0;
4696 while(input_value) {
4697 if (input_value & 1) {
4698 if( !ret.empty()) ret.append("|");
4699 ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(1U << index)));
4700 }
4701 ++index;
4702 input_value >>= 1;
4703 }
4704 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(0)));
4705 return ret;
4706 }
4707
string_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits input_value)4708 static inline const char* string_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits input_value)
4709 {
4710 switch (input_value)
4711 {
4712 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
4713 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
4714 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4715 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4716 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4717 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4718 case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
4719 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
4720 default:
4721 return "Unhandled VkExternalFenceHandleTypeFlagBits";
4722 }
4723 }
4724
string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value)4725 static inline std::string string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value)
4726 {
4727 std::string ret;
4728 int index = 0;
4729 while(input_value) {
4730 if (input_value & 1) {
4731 if( !ret.empty()) ret.append("|");
4732 ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(1U << index)));
4733 }
4734 ++index;
4735 input_value >>= 1;
4736 }
4737 if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(0)));
4738 return ret;
4739 }
4740
string_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits input_value)4741 static inline const char* string_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits input_value)
4742 {
4743 switch (input_value)
4744 {
4745 case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
4746 return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
4747 case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
4748 return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
4749 default:
4750 return "Unhandled VkExternalFenceFeatureFlagBits";
4751 }
4752 }
4753
string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value)4754 static inline std::string string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value)
4755 {
4756 std::string ret;
4757 int index = 0;
4758 while(input_value) {
4759 if (input_value & 1) {
4760 if( !ret.empty()) ret.append("|");
4761 ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(1U << index)));
4762 }
4763 ++index;
4764 input_value >>= 1;
4765 }
4766 if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(0)));
4767 return ret;
4768 }
4769
string_VkFenceImportFlagBits(VkFenceImportFlagBits input_value)4770 static inline const char* string_VkFenceImportFlagBits(VkFenceImportFlagBits input_value)
4771 {
4772 switch (input_value)
4773 {
4774 case VK_FENCE_IMPORT_TEMPORARY_BIT:
4775 return "VK_FENCE_IMPORT_TEMPORARY_BIT";
4776 default:
4777 return "Unhandled VkFenceImportFlagBits";
4778 }
4779 }
4780
string_VkFenceImportFlags(VkFenceImportFlags input_value)4781 static inline std::string string_VkFenceImportFlags(VkFenceImportFlags input_value)
4782 {
4783 std::string ret;
4784 int index = 0;
4785 while(input_value) {
4786 if (input_value & 1) {
4787 if( !ret.empty()) ret.append("|");
4788 ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(1U << index)));
4789 }
4790 ++index;
4791 input_value >>= 1;
4792 }
4793 if( ret.empty()) ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(0)));
4794 return ret;
4795 }
4796
string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits input_value)4797 static inline const char* string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits input_value)
4798 {
4799 switch (input_value)
4800 {
4801 case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
4802 return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
4803 default:
4804 return "Unhandled VkSemaphoreImportFlagBits";
4805 }
4806 }
4807
string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value)4808 static inline std::string string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value)
4809 {
4810 std::string ret;
4811 int index = 0;
4812 while(input_value) {
4813 if (input_value & 1) {
4814 if( !ret.empty()) ret.append("|");
4815 ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(1U << index)));
4816 }
4817 ++index;
4818 input_value >>= 1;
4819 }
4820 if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(0)));
4821 return ret;
4822 }
4823
string_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits input_value)4824 static inline const char* string_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits input_value)
4825 {
4826 switch (input_value)
4827 {
4828 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
4829 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
4830 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
4831 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
4832 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
4833 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
4834 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
4835 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
4836 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
4837 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
4838 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA:
4839 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA";
4840 default:
4841 return "Unhandled VkExternalSemaphoreHandleTypeFlagBits";
4842 }
4843 }
4844
string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value)4845 static inline std::string string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value)
4846 {
4847 std::string ret;
4848 int index = 0;
4849 while(input_value) {
4850 if (input_value & 1) {
4851 if( !ret.empty()) ret.append("|");
4852 ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(1U << index)));
4853 }
4854 ++index;
4855 input_value >>= 1;
4856 }
4857 if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(0)));
4858 return ret;
4859 }
4860
string_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits input_value)4861 static inline const char* string_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits input_value)
4862 {
4863 switch (input_value)
4864 {
4865 case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
4866 return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
4867 case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
4868 return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
4869 default:
4870 return "Unhandled VkExternalSemaphoreFeatureFlagBits";
4871 }
4872 }
4873
string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value)4874 static inline std::string string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value)
4875 {
4876 std::string ret;
4877 int index = 0;
4878 while(input_value) {
4879 if (input_value & 1) {
4880 if( !ret.empty()) ret.append("|");
4881 ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(1U << index)));
4882 }
4883 ++index;
4884 input_value >>= 1;
4885 }
4886 if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(0)));
4887 return ret;
4888 }
4889
string_VkDriverId(VkDriverId input_value)4890 static inline const char* string_VkDriverId(VkDriverId input_value)
4891 {
4892 switch (input_value)
4893 {
4894 case VK_DRIVER_ID_AMD_OPEN_SOURCE:
4895 return "VK_DRIVER_ID_AMD_OPEN_SOURCE";
4896 case VK_DRIVER_ID_AMD_PROPRIETARY:
4897 return "VK_DRIVER_ID_AMD_PROPRIETARY";
4898 case VK_DRIVER_ID_ARM_PROPRIETARY:
4899 return "VK_DRIVER_ID_ARM_PROPRIETARY";
4900 case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
4901 return "VK_DRIVER_ID_BROADCOM_PROPRIETARY";
4902 case VK_DRIVER_ID_COREAVI_PROPRIETARY:
4903 return "VK_DRIVER_ID_COREAVI_PROPRIETARY";
4904 case VK_DRIVER_ID_GGP_PROPRIETARY:
4905 return "VK_DRIVER_ID_GGP_PROPRIETARY";
4906 case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
4907 return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER";
4908 case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
4909 return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY";
4910 case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
4911 return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
4912 case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
4913 return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
4914 case VK_DRIVER_ID_JUICE_PROPRIETARY:
4915 return "VK_DRIVER_ID_JUICE_PROPRIETARY";
4916 case VK_DRIVER_ID_MESA_LLVMPIPE:
4917 return "VK_DRIVER_ID_MESA_LLVMPIPE";
4918 case VK_DRIVER_ID_MESA_RADV:
4919 return "VK_DRIVER_ID_MESA_RADV";
4920 case VK_DRIVER_ID_MOLTENVK:
4921 return "VK_DRIVER_ID_MOLTENVK";
4922 case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
4923 return "VK_DRIVER_ID_NVIDIA_PROPRIETARY";
4924 case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
4925 return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY";
4926 default:
4927 return "Unhandled VkDriverId";
4928 }
4929 }
4930
string_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence input_value)4931 static inline const char* string_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence input_value)
4932 {
4933 switch (input_value)
4934 {
4935 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY:
4936 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
4937 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL:
4938 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
4939 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE:
4940 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
4941 default:
4942 return "Unhandled VkShaderFloatControlsIndependence";
4943 }
4944 }
4945
string_VkResolveModeFlagBits(VkResolveModeFlagBits input_value)4946 static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits input_value)
4947 {
4948 switch (input_value)
4949 {
4950 case VK_RESOLVE_MODE_AVERAGE_BIT:
4951 return "VK_RESOLVE_MODE_AVERAGE_BIT";
4952 case VK_RESOLVE_MODE_MAX_BIT:
4953 return "VK_RESOLVE_MODE_MAX_BIT";
4954 case VK_RESOLVE_MODE_MIN_BIT:
4955 return "VK_RESOLVE_MODE_MIN_BIT";
4956 case VK_RESOLVE_MODE_NONE:
4957 return "VK_RESOLVE_MODE_NONE";
4958 case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT:
4959 return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT";
4960 default:
4961 return "Unhandled VkResolveModeFlagBits";
4962 }
4963 }
4964
string_VkResolveModeFlags(VkResolveModeFlags input_value)4965 static inline std::string string_VkResolveModeFlags(VkResolveModeFlags input_value)
4966 {
4967 std::string ret;
4968 int index = 0;
4969 while(input_value) {
4970 if (input_value & 1) {
4971 if( !ret.empty()) ret.append("|");
4972 ret.append(string_VkResolveModeFlagBits(static_cast<VkResolveModeFlagBits>(1U << index)));
4973 }
4974 ++index;
4975 input_value >>= 1;
4976 }
4977 if( ret.empty()) ret.append(string_VkResolveModeFlagBits(static_cast<VkResolveModeFlagBits>(0)));
4978 return ret;
4979 }
4980
string_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits input_value)4981 static inline const char* string_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits input_value)
4982 {
4983 switch (input_value)
4984 {
4985 case VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT:
4986 return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT";
4987 case VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT:
4988 return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT";
4989 case VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT:
4990 return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT";
4991 case VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT:
4992 return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT";
4993 default:
4994 return "Unhandled VkDescriptorBindingFlagBits";
4995 }
4996 }
4997
string_VkDescriptorBindingFlags(VkDescriptorBindingFlags input_value)4998 static inline std::string string_VkDescriptorBindingFlags(VkDescriptorBindingFlags input_value)
4999 {
5000 std::string ret;
5001 int index = 0;
5002 while(input_value) {
5003 if (input_value & 1) {
5004 if( !ret.empty()) ret.append("|");
5005 ret.append(string_VkDescriptorBindingFlagBits(static_cast<VkDescriptorBindingFlagBits>(1U << index)));
5006 }
5007 ++index;
5008 input_value >>= 1;
5009 }
5010 if( ret.empty()) ret.append(string_VkDescriptorBindingFlagBits(static_cast<VkDescriptorBindingFlagBits>(0)));
5011 return ret;
5012 }
5013
string_VkSamplerReductionMode(VkSamplerReductionMode input_value)5014 static inline const char* string_VkSamplerReductionMode(VkSamplerReductionMode input_value)
5015 {
5016 switch (input_value)
5017 {
5018 case VK_SAMPLER_REDUCTION_MODE_MAX:
5019 return "VK_SAMPLER_REDUCTION_MODE_MAX";
5020 case VK_SAMPLER_REDUCTION_MODE_MIN:
5021 return "VK_SAMPLER_REDUCTION_MODE_MIN";
5022 case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
5023 return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE";
5024 default:
5025 return "Unhandled VkSamplerReductionMode";
5026 }
5027 }
5028
string_VkSemaphoreType(VkSemaphoreType input_value)5029 static inline const char* string_VkSemaphoreType(VkSemaphoreType input_value)
5030 {
5031 switch (input_value)
5032 {
5033 case VK_SEMAPHORE_TYPE_BINARY:
5034 return "VK_SEMAPHORE_TYPE_BINARY";
5035 case VK_SEMAPHORE_TYPE_TIMELINE:
5036 return "VK_SEMAPHORE_TYPE_TIMELINE";
5037 default:
5038 return "Unhandled VkSemaphoreType";
5039 }
5040 }
5041
string_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits input_value)5042 static inline const char* string_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits input_value)
5043 {
5044 switch (input_value)
5045 {
5046 case VK_SEMAPHORE_WAIT_ANY_BIT:
5047 return "VK_SEMAPHORE_WAIT_ANY_BIT";
5048 default:
5049 return "Unhandled VkSemaphoreWaitFlagBits";
5050 }
5051 }
5052
string_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags input_value)5053 static inline std::string string_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags input_value)
5054 {
5055 std::string ret;
5056 int index = 0;
5057 while(input_value) {
5058 if (input_value & 1) {
5059 if( !ret.empty()) ret.append("|");
5060 ret.append(string_VkSemaphoreWaitFlagBits(static_cast<VkSemaphoreWaitFlagBits>(1U << index)));
5061 }
5062 ++index;
5063 input_value >>= 1;
5064 }
5065 if( ret.empty()) ret.append(string_VkSemaphoreWaitFlagBits(static_cast<VkSemaphoreWaitFlagBits>(0)));
5066 return ret;
5067 }
5068
string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)5069 static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)
5070 {
5071 switch (input_value)
5072 {
5073 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
5074 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR";
5075 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
5076 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR";
5077 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
5078 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR";
5079 case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
5080 return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR";
5081 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
5082 return "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR";
5083 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
5084 return "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR";
5085 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
5086 return "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR";
5087 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
5088 return "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR";
5089 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
5090 return "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR";
5091 default:
5092 return "Unhandled VkSurfaceTransformFlagBitsKHR";
5093 }
5094 }
5095
string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value)5096 static inline std::string string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value)
5097 {
5098 std::string ret;
5099 int index = 0;
5100 while(input_value) {
5101 if (input_value & 1) {
5102 if( !ret.empty()) ret.append("|");
5103 ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(1U << index)));
5104 }
5105 ++index;
5106 input_value >>= 1;
5107 }
5108 if( ret.empty()) ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(0)));
5109 return ret;
5110 }
5111
string_VkPresentModeKHR(VkPresentModeKHR input_value)5112 static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value)
5113 {
5114 switch (input_value)
5115 {
5116 case VK_PRESENT_MODE_FIFO_KHR:
5117 return "VK_PRESENT_MODE_FIFO_KHR";
5118 case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
5119 return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
5120 case VK_PRESENT_MODE_IMMEDIATE_KHR:
5121 return "VK_PRESENT_MODE_IMMEDIATE_KHR";
5122 case VK_PRESENT_MODE_MAILBOX_KHR:
5123 return "VK_PRESENT_MODE_MAILBOX_KHR";
5124 case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
5125 return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
5126 case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
5127 return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
5128 default:
5129 return "Unhandled VkPresentModeKHR";
5130 }
5131 }
5132
string_VkColorSpaceKHR(VkColorSpaceKHR input_value)5133 static inline const char* string_VkColorSpaceKHR(VkColorSpaceKHR input_value)
5134 {
5135 switch (input_value)
5136 {
5137 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
5138 return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT";
5139 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
5140 return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
5141 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
5142 return "VK_COLOR_SPACE_BT2020_LINEAR_EXT";
5143 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
5144 return "VK_COLOR_SPACE_BT709_LINEAR_EXT";
5145 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
5146 return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT";
5147 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
5148 return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
5149 case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD:
5150 return "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD";
5151 case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT:
5152 return "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
5153 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
5154 return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
5155 case VK_COLOR_SPACE_DOLBYVISION_EXT:
5156 return "VK_COLOR_SPACE_DOLBYVISION_EXT";
5157 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
5158 return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
5159 case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
5160 return "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
5161 case VK_COLOR_SPACE_HDR10_HLG_EXT:
5162 return "VK_COLOR_SPACE_HDR10_HLG_EXT";
5163 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
5164 return "VK_COLOR_SPACE_HDR10_ST2084_EXT";
5165 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
5166 return "VK_COLOR_SPACE_PASS_THROUGH_EXT";
5167 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
5168 return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
5169 default:
5170 return "Unhandled VkColorSpaceKHR";
5171 }
5172 }
5173
string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)5174 static inline const char* string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)
5175 {
5176 switch (input_value)
5177 {
5178 case VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR:
5179 return "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR";
5180 case VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR:
5181 return "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR";
5182 case VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR:
5183 return "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR";
5184 case VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR:
5185 return "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR";
5186 default:
5187 return "Unhandled VkCompositeAlphaFlagBitsKHR";
5188 }
5189 }
5190
string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value)5191 static inline std::string string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value)
5192 {
5193 std::string ret;
5194 int index = 0;
5195 while(input_value) {
5196 if (input_value & 1) {
5197 if( !ret.empty()) ret.append("|");
5198 ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(1U << index)));
5199 }
5200 ++index;
5201 input_value >>= 1;
5202 }
5203 if( ret.empty()) ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(0)));
5204 return ret;
5205 }
5206
string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)5207 static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)
5208 {
5209 switch (input_value)
5210 {
5211 case VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR:
5212 return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
5213 case VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR:
5214 return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR";
5215 case VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR:
5216 return "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR";
5217 default:
5218 return "Unhandled VkSwapchainCreateFlagBitsKHR";
5219 }
5220 }
5221
string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value)5222 static inline std::string string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value)
5223 {
5224 std::string ret;
5225 int index = 0;
5226 while(input_value) {
5227 if (input_value & 1) {
5228 if( !ret.empty()) ret.append("|");
5229 ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(1U << index)));
5230 }
5231 ++index;
5232 input_value >>= 1;
5233 }
5234 if( ret.empty()) ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(0)));
5235 return ret;
5236 }
5237
string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR input_value)5238 static inline const char* string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR input_value)
5239 {
5240 switch (input_value)
5241 {
5242 case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR:
5243 return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR";
5244 case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR:
5245 return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR";
5246 case VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR:
5247 return "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR";
5248 case VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR:
5249 return "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR";
5250 default:
5251 return "Unhandled VkDeviceGroupPresentModeFlagBitsKHR";
5252 }
5253 }
5254
string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value)5255 static inline std::string string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value)
5256 {
5257 std::string ret;
5258 int index = 0;
5259 while(input_value) {
5260 if (input_value & 1) {
5261 if( !ret.empty()) ret.append("|");
5262 ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(1U << index)));
5263 }
5264 ++index;
5265 input_value >>= 1;
5266 }
5267 if( ret.empty()) ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(0)));
5268 return ret;
5269 }
5270
string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)5271 static inline const char* string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)
5272 {
5273 switch (input_value)
5274 {
5275 case VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR:
5276 return "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR";
5277 case VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR:
5278 return "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR";
5279 case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR:
5280 return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR";
5281 case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR:
5282 return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR";
5283 default:
5284 return "Unhandled VkDisplayPlaneAlphaFlagBitsKHR";
5285 }
5286 }
5287
string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value)5288 static inline std::string string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value)
5289 {
5290 std::string ret;
5291 int index = 0;
5292 while(input_value) {
5293 if (input_value & 1) {
5294 if( !ret.empty()) ret.append("|");
5295 ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(1U << index)));
5296 }
5297 ++index;
5298 input_value >>= 1;
5299 }
5300 if( ret.empty()) ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(0)));
5301 return ret;
5302 }
5303
5304
5305 #ifdef VK_ENABLE_BETA_EXTENSIONS
5306
string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOperationFlagBitsKHR input_value)5307 static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOperationFlagBitsKHR input_value)
5308 {
5309 switch (input_value)
5310 {
5311 #ifdef VK_ENABLE_BETA_EXTENSIONS
5312 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT:
5313 return "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT";
5314 #endif // VK_ENABLE_BETA_EXTENSIONS
5315 #ifdef VK_ENABLE_BETA_EXTENSIONS
5316 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT:
5317 return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT";
5318 #endif // VK_ENABLE_BETA_EXTENSIONS
5319 #ifdef VK_ENABLE_BETA_EXTENSIONS
5320 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT:
5321 return "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT";
5322 #endif // VK_ENABLE_BETA_EXTENSIONS
5323 case VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR:
5324 return "VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR";
5325 default:
5326 return "Unhandled VkVideoCodecOperationFlagBitsKHR";
5327 }
5328 }
5329
string_VkVideoCodecOperationFlagsKHR(VkVideoCodecOperationFlagsKHR input_value)5330 static inline std::string string_VkVideoCodecOperationFlagsKHR(VkVideoCodecOperationFlagsKHR input_value)
5331 {
5332 std::string ret;
5333 int index = 0;
5334 while(input_value) {
5335 if (input_value & 1) {
5336 if( !ret.empty()) ret.append("|");
5337 ret.append(string_VkVideoCodecOperationFlagBitsKHR(static_cast<VkVideoCodecOperationFlagBitsKHR>(1U << index)));
5338 }
5339 ++index;
5340 input_value >>= 1;
5341 }
5342 if( ret.empty()) ret.append(string_VkVideoCodecOperationFlagBitsKHR(static_cast<VkVideoCodecOperationFlagBitsKHR>(0)));
5343 return ret;
5344 }
5345 #endif // VK_ENABLE_BETA_EXTENSIONS
5346
5347
5348 #ifdef VK_ENABLE_BETA_EXTENSIONS
5349
string_VkVideoChromaSubsamplingFlagBitsKHR(VkVideoChromaSubsamplingFlagBitsKHR input_value)5350 static inline const char* string_VkVideoChromaSubsamplingFlagBitsKHR(VkVideoChromaSubsamplingFlagBitsKHR input_value)
5351 {
5352 switch (input_value)
5353 {
5354 case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR:
5355 return "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR";
5356 case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR:
5357 return "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR";
5358 case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR:
5359 return "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR";
5360 case VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR:
5361 return "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR";
5362 case VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR:
5363 return "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR";
5364 default:
5365 return "Unhandled VkVideoChromaSubsamplingFlagBitsKHR";
5366 }
5367 }
5368
string_VkVideoChromaSubsamplingFlagsKHR(VkVideoChromaSubsamplingFlagsKHR input_value)5369 static inline std::string string_VkVideoChromaSubsamplingFlagsKHR(VkVideoChromaSubsamplingFlagsKHR input_value)
5370 {
5371 std::string ret;
5372 int index = 0;
5373 while(input_value) {
5374 if (input_value & 1) {
5375 if( !ret.empty()) ret.append("|");
5376 ret.append(string_VkVideoChromaSubsamplingFlagBitsKHR(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(1U << index)));
5377 }
5378 ++index;
5379 input_value >>= 1;
5380 }
5381 if( ret.empty()) ret.append(string_VkVideoChromaSubsamplingFlagBitsKHR(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(0)));
5382 return ret;
5383 }
5384 #endif // VK_ENABLE_BETA_EXTENSIONS
5385
5386
5387 #ifdef VK_ENABLE_BETA_EXTENSIONS
5388
string_VkVideoComponentBitDepthFlagBitsKHR(VkVideoComponentBitDepthFlagBitsKHR input_value)5389 static inline const char* string_VkVideoComponentBitDepthFlagBitsKHR(VkVideoComponentBitDepthFlagBitsKHR input_value)
5390 {
5391 switch (input_value)
5392 {
5393 case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
5394 return "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR";
5395 case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
5396 return "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR";
5397 case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
5398 return "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR";
5399 case VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR:
5400 return "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR";
5401 default:
5402 return "Unhandled VkVideoComponentBitDepthFlagBitsKHR";
5403 }
5404 }
5405
string_VkVideoComponentBitDepthFlagsKHR(VkVideoComponentBitDepthFlagsKHR input_value)5406 static inline std::string string_VkVideoComponentBitDepthFlagsKHR(VkVideoComponentBitDepthFlagsKHR input_value)
5407 {
5408 std::string ret;
5409 int index = 0;
5410 while(input_value) {
5411 if (input_value & 1) {
5412 if( !ret.empty()) ret.append("|");
5413 ret.append(string_VkVideoComponentBitDepthFlagBitsKHR(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(1U << index)));
5414 }
5415 ++index;
5416 input_value >>= 1;
5417 }
5418 if( ret.empty()) ret.append(string_VkVideoComponentBitDepthFlagBitsKHR(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(0)));
5419 return ret;
5420 }
5421 #endif // VK_ENABLE_BETA_EXTENSIONS
5422
5423
5424 #ifdef VK_ENABLE_BETA_EXTENSIONS
5425
string_VkVideoCapabilitiesFlagBitsKHR(VkVideoCapabilitiesFlagBitsKHR input_value)5426 static inline const char* string_VkVideoCapabilitiesFlagBitsKHR(VkVideoCapabilitiesFlagBitsKHR input_value)
5427 {
5428 switch (input_value)
5429 {
5430 case VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR:
5431 return "VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR";
5432 case VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR:
5433 return "VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR";
5434 default:
5435 return "Unhandled VkVideoCapabilitiesFlagBitsKHR";
5436 }
5437 }
5438
string_VkVideoCapabilitiesFlagsKHR(VkVideoCapabilitiesFlagsKHR input_value)5439 static inline std::string string_VkVideoCapabilitiesFlagsKHR(VkVideoCapabilitiesFlagsKHR input_value)
5440 {
5441 std::string ret;
5442 int index = 0;
5443 while(input_value) {
5444 if (input_value & 1) {
5445 if( !ret.empty()) ret.append("|");
5446 ret.append(string_VkVideoCapabilitiesFlagBitsKHR(static_cast<VkVideoCapabilitiesFlagBitsKHR>(1U << index)));
5447 }
5448 ++index;
5449 input_value >>= 1;
5450 }
5451 if( ret.empty()) ret.append(string_VkVideoCapabilitiesFlagBitsKHR(static_cast<VkVideoCapabilitiesFlagBitsKHR>(0)));
5452 return ret;
5453 }
5454 #endif // VK_ENABLE_BETA_EXTENSIONS
5455
5456
5457 #ifdef VK_ENABLE_BETA_EXTENSIONS
5458
string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionCreateFlagBitsKHR input_value)5459 static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionCreateFlagBitsKHR input_value)
5460 {
5461 switch (input_value)
5462 {
5463 case VK_VIDEO_SESSION_CREATE_DEFAULT_KHR:
5464 return "VK_VIDEO_SESSION_CREATE_DEFAULT_KHR";
5465 case VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR:
5466 return "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR";
5467 default:
5468 return "Unhandled VkVideoSessionCreateFlagBitsKHR";
5469 }
5470 }
5471
string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCreateFlagsKHR input_value)5472 static inline std::string string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCreateFlagsKHR input_value)
5473 {
5474 std::string ret;
5475 int index = 0;
5476 while(input_value) {
5477 if (input_value & 1) {
5478 if( !ret.empty()) ret.append("|");
5479 ret.append(string_VkVideoSessionCreateFlagBitsKHR(static_cast<VkVideoSessionCreateFlagBitsKHR>(1U << index)));
5480 }
5481 ++index;
5482 input_value >>= 1;
5483 }
5484 if( ret.empty()) ret.append(string_VkVideoSessionCreateFlagBitsKHR(static_cast<VkVideoSessionCreateFlagBitsKHR>(0)));
5485 return ret;
5486 }
5487 #endif // VK_ENABLE_BETA_EXTENSIONS
5488
5489
5490 #ifdef VK_ENABLE_BETA_EXTENSIONS
5491
string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value)5492 static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value)
5493 {
5494 switch (input_value)
5495 {
5496 case VK_VIDEO_CODING_CONTROL_DEFAULT_KHR:
5497 return "VK_VIDEO_CODING_CONTROL_DEFAULT_KHR";
5498 case VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR:
5499 return "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR";
5500 default:
5501 return "Unhandled VkVideoCodingControlFlagBitsKHR";
5502 }
5503 }
5504
string_VkVideoCodingControlFlagsKHR(VkVideoCodingControlFlagsKHR input_value)5505 static inline std::string string_VkVideoCodingControlFlagsKHR(VkVideoCodingControlFlagsKHR input_value)
5506 {
5507 std::string ret;
5508 int index = 0;
5509 while(input_value) {
5510 if (input_value & 1) {
5511 if( !ret.empty()) ret.append("|");
5512 ret.append(string_VkVideoCodingControlFlagBitsKHR(static_cast<VkVideoCodingControlFlagBitsKHR>(1U << index)));
5513 }
5514 ++index;
5515 input_value >>= 1;
5516 }
5517 if( ret.empty()) ret.append(string_VkVideoCodingControlFlagBitsKHR(static_cast<VkVideoCodingControlFlagBitsKHR>(0)));
5518 return ret;
5519 }
5520 #endif // VK_ENABLE_BETA_EXTENSIONS
5521
5522
5523 #ifdef VK_ENABLE_BETA_EXTENSIONS
5524
string_VkVideoCodingQualityPresetFlagBitsKHR(VkVideoCodingQualityPresetFlagBitsKHR input_value)5525 static inline const char* string_VkVideoCodingQualityPresetFlagBitsKHR(VkVideoCodingQualityPresetFlagBitsKHR input_value)
5526 {
5527 switch (input_value)
5528 {
5529 case VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR:
5530 return "VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR";
5531 case VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR:
5532 return "VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR";
5533 case VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR:
5534 return "VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR";
5535 case VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR:
5536 return "VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR";
5537 default:
5538 return "Unhandled VkVideoCodingQualityPresetFlagBitsKHR";
5539 }
5540 }
5541
string_VkVideoCodingQualityPresetFlagsKHR(VkVideoCodingQualityPresetFlagsKHR input_value)5542 static inline std::string string_VkVideoCodingQualityPresetFlagsKHR(VkVideoCodingQualityPresetFlagsKHR input_value)
5543 {
5544 std::string ret;
5545 int index = 0;
5546 while(input_value) {
5547 if (input_value & 1) {
5548 if( !ret.empty()) ret.append("|");
5549 ret.append(string_VkVideoCodingQualityPresetFlagBitsKHR(static_cast<VkVideoCodingQualityPresetFlagBitsKHR>(1U << index)));
5550 }
5551 ++index;
5552 input_value >>= 1;
5553 }
5554 if( ret.empty()) ret.append(string_VkVideoCodingQualityPresetFlagBitsKHR(static_cast<VkVideoCodingQualityPresetFlagBitsKHR>(0)));
5555 return ret;
5556 }
5557 #endif // VK_ENABLE_BETA_EXTENSIONS
5558
5559
5560 #ifdef VK_ENABLE_BETA_EXTENSIONS
5561
string_VkQueryResultStatusKHR(VkQueryResultStatusKHR input_value)5562 static inline const char* string_VkQueryResultStatusKHR(VkQueryResultStatusKHR input_value)
5563 {
5564 switch (input_value)
5565 {
5566 case VK_QUERY_RESULT_STATUS_COMPLETE_KHR:
5567 return "VK_QUERY_RESULT_STATUS_COMPLETE_KHR";
5568 case VK_QUERY_RESULT_STATUS_ERROR_KHR:
5569 return "VK_QUERY_RESULT_STATUS_ERROR_KHR";
5570 case VK_QUERY_RESULT_STATUS_NOT_READY_KHR:
5571 return "VK_QUERY_RESULT_STATUS_NOT_READY_KHR";
5572 default:
5573 return "Unhandled VkQueryResultStatusKHR";
5574 }
5575 }
5576 #endif // VK_ENABLE_BETA_EXTENSIONS
5577
5578
5579 #ifdef VK_ENABLE_BETA_EXTENSIONS
5580
string_VkVideoDecodeFlagBitsKHR(VkVideoDecodeFlagBitsKHR input_value)5581 static inline const char* string_VkVideoDecodeFlagBitsKHR(VkVideoDecodeFlagBitsKHR input_value)
5582 {
5583 switch (input_value)
5584 {
5585 case VK_VIDEO_DECODE_DEFAULT_KHR:
5586 return "VK_VIDEO_DECODE_DEFAULT_KHR";
5587 case VK_VIDEO_DECODE_RESERVED_0_BIT_KHR:
5588 return "VK_VIDEO_DECODE_RESERVED_0_BIT_KHR";
5589 default:
5590 return "Unhandled VkVideoDecodeFlagBitsKHR";
5591 }
5592 }
5593
string_VkVideoDecodeFlagsKHR(VkVideoDecodeFlagsKHR input_value)5594 static inline std::string string_VkVideoDecodeFlagsKHR(VkVideoDecodeFlagsKHR input_value)
5595 {
5596 std::string ret;
5597 int index = 0;
5598 while(input_value) {
5599 if (input_value & 1) {
5600 if( !ret.empty()) ret.append("|");
5601 ret.append(string_VkVideoDecodeFlagBitsKHR(static_cast<VkVideoDecodeFlagBitsKHR>(1U << index)));
5602 }
5603 ++index;
5604 input_value >>= 1;
5605 }
5606 if( ret.empty()) ret.append(string_VkVideoDecodeFlagBitsKHR(static_cast<VkVideoDecodeFlagBitsKHR>(0)));
5607 return ret;
5608 }
5609 #endif // VK_ENABLE_BETA_EXTENSIONS
5610
string_VkPeerMemoryFeatureFlagBitsKHR(VkPeerMemoryFeatureFlagBitsKHR input_value)5611 static inline const char* string_VkPeerMemoryFeatureFlagBitsKHR(VkPeerMemoryFeatureFlagBitsKHR input_value)
5612 {
5613 switch (input_value)
5614 {
5615 case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
5616 return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
5617 case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
5618 return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
5619 case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
5620 return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
5621 case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
5622 return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
5623 default:
5624 return "Unhandled VkPeerMemoryFeatureFlagBitsKHR";
5625 }
5626 }
5627
string_VkPeerMemoryFeatureFlagsKHR(VkPeerMemoryFeatureFlagsKHR input_value)5628 static inline std::string string_VkPeerMemoryFeatureFlagsKHR(VkPeerMemoryFeatureFlagsKHR input_value)
5629 {
5630 std::string ret;
5631 int index = 0;
5632 while(input_value) {
5633 if (input_value & 1) {
5634 if( !ret.empty()) ret.append("|");
5635 ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(1U << index)));
5636 }
5637 ++index;
5638 input_value >>= 1;
5639 }
5640 if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(0)));
5641 return ret;
5642 }
5643
string_VkMemoryAllocateFlagBitsKHR(VkMemoryAllocateFlagBitsKHR input_value)5644 static inline const char* string_VkMemoryAllocateFlagBitsKHR(VkMemoryAllocateFlagBitsKHR input_value)
5645 {
5646 switch (input_value)
5647 {
5648 case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT:
5649 return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
5650 case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
5651 return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
5652 case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
5653 return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
5654 default:
5655 return "Unhandled VkMemoryAllocateFlagBitsKHR";
5656 }
5657 }
5658
string_VkMemoryAllocateFlagsKHR(VkMemoryAllocateFlagsKHR input_value)5659 static inline std::string string_VkMemoryAllocateFlagsKHR(VkMemoryAllocateFlagsKHR input_value)
5660 {
5661 std::string ret;
5662 int index = 0;
5663 while(input_value) {
5664 if (input_value & 1) {
5665 if( !ret.empty()) ret.append("|");
5666 ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(1U << index)));
5667 }
5668 ++index;
5669 input_value >>= 1;
5670 }
5671 if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(0)));
5672 return ret;
5673 }
5674
string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)5675 static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)
5676 {
5677 switch (input_value)
5678 {
5679 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
5680 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
5681 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
5682 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
5683 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
5684 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
5685 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
5686 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
5687 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
5688 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
5689 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
5690 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
5691 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
5692 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
5693 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
5694 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
5695 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
5696 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
5697 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
5698 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
5699 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
5700 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
5701 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA:
5702 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA";
5703 default:
5704 return "Unhandled VkExternalMemoryHandleTypeFlagBitsKHR";
5705 }
5706 }
5707
string_VkExternalMemoryHandleTypeFlagsKHR(VkExternalMemoryHandleTypeFlagsKHR input_value)5708 static inline std::string string_VkExternalMemoryHandleTypeFlagsKHR(VkExternalMemoryHandleTypeFlagsKHR input_value)
5709 {
5710 std::string ret;
5711 int index = 0;
5712 while(input_value) {
5713 if (input_value & 1) {
5714 if( !ret.empty()) ret.append("|");
5715 ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(1U << index)));
5716 }
5717 ++index;
5718 input_value >>= 1;
5719 }
5720 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(0)));
5721 return ret;
5722 }
5723
string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)5724 static inline const char* string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)
5725 {
5726 switch (input_value)
5727 {
5728 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
5729 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
5730 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
5731 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
5732 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
5733 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
5734 default:
5735 return "Unhandled VkExternalMemoryFeatureFlagBitsKHR";
5736 }
5737 }
5738
string_VkExternalMemoryFeatureFlagsKHR(VkExternalMemoryFeatureFlagsKHR input_value)5739 static inline std::string string_VkExternalMemoryFeatureFlagsKHR(VkExternalMemoryFeatureFlagsKHR input_value)
5740 {
5741 std::string ret;
5742 int index = 0;
5743 while(input_value) {
5744 if (input_value & 1) {
5745 if( !ret.empty()) ret.append("|");
5746 ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(1U << index)));
5747 }
5748 ++index;
5749 input_value >>= 1;
5750 }
5751 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(0)));
5752 return ret;
5753 }
5754
string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)5755 static inline const char* string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)
5756 {
5757 switch (input_value)
5758 {
5759 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
5760 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
5761 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
5762 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
5763 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
5764 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
5765 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
5766 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
5767 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
5768 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
5769 case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA:
5770 return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA";
5771 default:
5772 return "Unhandled VkExternalSemaphoreHandleTypeFlagBitsKHR";
5773 }
5774 }
5775
string_VkExternalSemaphoreHandleTypeFlagsKHR(VkExternalSemaphoreHandleTypeFlagsKHR input_value)5776 static inline std::string string_VkExternalSemaphoreHandleTypeFlagsKHR(VkExternalSemaphoreHandleTypeFlagsKHR input_value)
5777 {
5778 std::string ret;
5779 int index = 0;
5780 while(input_value) {
5781 if (input_value & 1) {
5782 if( !ret.empty()) ret.append("|");
5783 ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(1U << index)));
5784 }
5785 ++index;
5786 input_value >>= 1;
5787 }
5788 if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(0)));
5789 return ret;
5790 }
5791
string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)5792 static inline const char* string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)
5793 {
5794 switch (input_value)
5795 {
5796 case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
5797 return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
5798 case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
5799 return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
5800 default:
5801 return "Unhandled VkExternalSemaphoreFeatureFlagBitsKHR";
5802 }
5803 }
5804
string_VkExternalSemaphoreFeatureFlagsKHR(VkExternalSemaphoreFeatureFlagsKHR input_value)5805 static inline std::string string_VkExternalSemaphoreFeatureFlagsKHR(VkExternalSemaphoreFeatureFlagsKHR input_value)
5806 {
5807 std::string ret;
5808 int index = 0;
5809 while(input_value) {
5810 if (input_value & 1) {
5811 if( !ret.empty()) ret.append("|");
5812 ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(1U << index)));
5813 }
5814 ++index;
5815 input_value >>= 1;
5816 }
5817 if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(0)));
5818 return ret;
5819 }
5820
string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)5821 static inline const char* string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)
5822 {
5823 switch (input_value)
5824 {
5825 case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
5826 return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
5827 default:
5828 return "Unhandled VkSemaphoreImportFlagBitsKHR";
5829 }
5830 }
5831
string_VkSemaphoreImportFlagsKHR(VkSemaphoreImportFlagsKHR input_value)5832 static inline std::string string_VkSemaphoreImportFlagsKHR(VkSemaphoreImportFlagsKHR input_value)
5833 {
5834 std::string ret;
5835 int index = 0;
5836 while(input_value) {
5837 if (input_value & 1) {
5838 if( !ret.empty()) ret.append("|");
5839 ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(1U << index)));
5840 }
5841 ++index;
5842 input_value >>= 1;
5843 }
5844 if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(0)));
5845 return ret;
5846 }
5847
string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)5848 static inline const char* string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)
5849 {
5850 switch (input_value)
5851 {
5852 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
5853 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
5854 case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
5855 return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
5856 default:
5857 return "Unhandled VkDescriptorUpdateTemplateTypeKHR";
5858 }
5859 }
5860
string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)5861 static inline const char* string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)
5862 {
5863 switch (input_value)
5864 {
5865 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
5866 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
5867 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
5868 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
5869 case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
5870 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
5871 case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
5872 return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
5873 default:
5874 return "Unhandled VkExternalFenceHandleTypeFlagBitsKHR";
5875 }
5876 }
5877
string_VkExternalFenceHandleTypeFlagsKHR(VkExternalFenceHandleTypeFlagsKHR input_value)5878 static inline std::string string_VkExternalFenceHandleTypeFlagsKHR(VkExternalFenceHandleTypeFlagsKHR input_value)
5879 {
5880 std::string ret;
5881 int index = 0;
5882 while(input_value) {
5883 if (input_value & 1) {
5884 if( !ret.empty()) ret.append("|");
5885 ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(1U << index)));
5886 }
5887 ++index;
5888 input_value >>= 1;
5889 }
5890 if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(0)));
5891 return ret;
5892 }
5893
string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)5894 static inline const char* string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)
5895 {
5896 switch (input_value)
5897 {
5898 case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
5899 return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
5900 case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
5901 return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
5902 default:
5903 return "Unhandled VkExternalFenceFeatureFlagBitsKHR";
5904 }
5905 }
5906
string_VkExternalFenceFeatureFlagsKHR(VkExternalFenceFeatureFlagsKHR input_value)5907 static inline std::string string_VkExternalFenceFeatureFlagsKHR(VkExternalFenceFeatureFlagsKHR input_value)
5908 {
5909 std::string ret;
5910 int index = 0;
5911 while(input_value) {
5912 if (input_value & 1) {
5913 if( !ret.empty()) ret.append("|");
5914 ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(1U << index)));
5915 }
5916 ++index;
5917 input_value >>= 1;
5918 }
5919 if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(0)));
5920 return ret;
5921 }
5922
string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)5923 static inline const char* string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)
5924 {
5925 switch (input_value)
5926 {
5927 case VK_FENCE_IMPORT_TEMPORARY_BIT:
5928 return "VK_FENCE_IMPORT_TEMPORARY_BIT";
5929 default:
5930 return "Unhandled VkFenceImportFlagBitsKHR";
5931 }
5932 }
5933
string_VkFenceImportFlagsKHR(VkFenceImportFlagsKHR input_value)5934 static inline std::string string_VkFenceImportFlagsKHR(VkFenceImportFlagsKHR input_value)
5935 {
5936 std::string ret;
5937 int index = 0;
5938 while(input_value) {
5939 if (input_value & 1) {
5940 if( !ret.empty()) ret.append("|");
5941 ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(1U << index)));
5942 }
5943 ++index;
5944 input_value >>= 1;
5945 }
5946 if( ret.empty()) ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(0)));
5947 return ret;
5948 }
5949
string_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR input_value)5950 static inline const char* string_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR input_value)
5951 {
5952 switch (input_value)
5953 {
5954 case VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR:
5955 return "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR";
5956 case VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR:
5957 return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR";
5958 case VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR:
5959 return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR";
5960 case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR:
5961 return "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR";
5962 case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR:
5963 return "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR";
5964 case VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR:
5965 return "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR";
5966 case VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR:
5967 return "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR";
5968 case VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR:
5969 return "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR";
5970 case VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR:
5971 return "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR";
5972 case VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR:
5973 return "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR";
5974 case VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR:
5975 return "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR";
5976 default:
5977 return "Unhandled VkPerformanceCounterUnitKHR";
5978 }
5979 }
5980
string_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR input_value)5981 static inline const char* string_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR input_value)
5982 {
5983 switch (input_value)
5984 {
5985 case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR:
5986 return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR";
5987 case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR:
5988 return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR";
5989 case VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR:
5990 return "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR";
5991 default:
5992 return "Unhandled VkPerformanceCounterScopeKHR";
5993 }
5994 }
5995
string_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR input_value)5996 static inline const char* string_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR input_value)
5997 {
5998 switch (input_value)
5999 {
6000 case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR:
6001 return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR";
6002 case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR:
6003 return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR";
6004 case VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR:
6005 return "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR";
6006 case VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR:
6007 return "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR";
6008 case VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR:
6009 return "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR";
6010 case VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR:
6011 return "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR";
6012 default:
6013 return "Unhandled VkPerformanceCounterStorageKHR";
6014 }
6015 }
6016
string_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR input_value)6017 static inline const char* string_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR input_value)
6018 {
6019 switch (input_value)
6020 {
6021 case VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR:
6022 return "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR";
6023 case VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR:
6024 return "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR";
6025 default:
6026 return "Unhandled VkPerformanceCounterDescriptionFlagBitsKHR";
6027 }
6028 }
6029
string_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR input_value)6030 static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR input_value)
6031 {
6032 std::string ret;
6033 int index = 0;
6034 while(input_value) {
6035 if (input_value & 1) {
6036 if( !ret.empty()) ret.append("|");
6037 ret.append(string_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(1U << index)));
6038 }
6039 ++index;
6040 input_value >>= 1;
6041 }
6042 if( ret.empty()) ret.append(string_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(0)));
6043 return ret;
6044 }
6045
string_VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR input_value)6046 static inline const char* string_VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR input_value)
6047 {
6048 switch (input_value)
6049 {
6050 case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
6051 return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
6052 case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
6053 return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
6054 default:
6055 return "Unhandled VkPointClippingBehaviorKHR";
6056 }
6057 }
6058
string_VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR input_value)6059 static inline const char* string_VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR input_value)
6060 {
6061 switch (input_value)
6062 {
6063 case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
6064 return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
6065 case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
6066 return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
6067 default:
6068 return "Unhandled VkTessellationDomainOriginKHR";
6069 }
6070 }
6071
string_VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR input_value)6072 static inline const char* string_VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR input_value)
6073 {
6074 switch (input_value)
6075 {
6076 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
6077 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
6078 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
6079 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
6080 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
6081 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
6082 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
6083 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
6084 case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
6085 return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
6086 default:
6087 return "Unhandled VkSamplerYcbcrModelConversionKHR";
6088 }
6089 }
6090
string_VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR input_value)6091 static inline const char* string_VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR input_value)
6092 {
6093 switch (input_value)
6094 {
6095 case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
6096 return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
6097 case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
6098 return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
6099 default:
6100 return "Unhandled VkSamplerYcbcrRangeKHR";
6101 }
6102 }
6103
string_VkChromaLocationKHR(VkChromaLocationKHR input_value)6104 static inline const char* string_VkChromaLocationKHR(VkChromaLocationKHR input_value)
6105 {
6106 switch (input_value)
6107 {
6108 case VK_CHROMA_LOCATION_COSITED_EVEN:
6109 return "VK_CHROMA_LOCATION_COSITED_EVEN";
6110 case VK_CHROMA_LOCATION_MIDPOINT:
6111 return "VK_CHROMA_LOCATION_MIDPOINT";
6112 default:
6113 return "Unhandled VkChromaLocationKHR";
6114 }
6115 }
6116
string_VkDriverIdKHR(VkDriverIdKHR input_value)6117 static inline const char* string_VkDriverIdKHR(VkDriverIdKHR input_value)
6118 {
6119 switch (input_value)
6120 {
6121 case VK_DRIVER_ID_AMD_OPEN_SOURCE:
6122 return "VK_DRIVER_ID_AMD_OPEN_SOURCE";
6123 case VK_DRIVER_ID_AMD_PROPRIETARY:
6124 return "VK_DRIVER_ID_AMD_PROPRIETARY";
6125 case VK_DRIVER_ID_ARM_PROPRIETARY:
6126 return "VK_DRIVER_ID_ARM_PROPRIETARY";
6127 case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
6128 return "VK_DRIVER_ID_BROADCOM_PROPRIETARY";
6129 case VK_DRIVER_ID_COREAVI_PROPRIETARY:
6130 return "VK_DRIVER_ID_COREAVI_PROPRIETARY";
6131 case VK_DRIVER_ID_GGP_PROPRIETARY:
6132 return "VK_DRIVER_ID_GGP_PROPRIETARY";
6133 case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
6134 return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER";
6135 case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
6136 return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY";
6137 case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
6138 return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
6139 case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
6140 return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
6141 case VK_DRIVER_ID_JUICE_PROPRIETARY:
6142 return "VK_DRIVER_ID_JUICE_PROPRIETARY";
6143 case VK_DRIVER_ID_MESA_LLVMPIPE:
6144 return "VK_DRIVER_ID_MESA_LLVMPIPE";
6145 case VK_DRIVER_ID_MESA_RADV:
6146 return "VK_DRIVER_ID_MESA_RADV";
6147 case VK_DRIVER_ID_MOLTENVK:
6148 return "VK_DRIVER_ID_MOLTENVK";
6149 case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
6150 return "VK_DRIVER_ID_NVIDIA_PROPRIETARY";
6151 case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
6152 return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY";
6153 default:
6154 return "Unhandled VkDriverIdKHR";
6155 }
6156 }
6157
string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)6158 static inline const char* string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)
6159 {
6160 switch (input_value)
6161 {
6162 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY:
6163 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
6164 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL:
6165 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
6166 case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE:
6167 return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
6168 default:
6169 return "Unhandled VkShaderFloatControlsIndependenceKHR";
6170 }
6171 }
6172
string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)6173 static inline const char* string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)
6174 {
6175 switch (input_value)
6176 {
6177 case VK_RESOLVE_MODE_AVERAGE_BIT:
6178 return "VK_RESOLVE_MODE_AVERAGE_BIT";
6179 case VK_RESOLVE_MODE_MAX_BIT:
6180 return "VK_RESOLVE_MODE_MAX_BIT";
6181 case VK_RESOLVE_MODE_MIN_BIT:
6182 return "VK_RESOLVE_MODE_MIN_BIT";
6183 case VK_RESOLVE_MODE_NONE:
6184 return "VK_RESOLVE_MODE_NONE";
6185 case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT:
6186 return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT";
6187 default:
6188 return "Unhandled VkResolveModeFlagBitsKHR";
6189 }
6190 }
6191
string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR input_value)6192 static inline std::string string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR input_value)
6193 {
6194 std::string ret;
6195 int index = 0;
6196 while(input_value) {
6197 if (input_value & 1) {
6198 if( !ret.empty()) ret.append("|");
6199 ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(1U << index)));
6200 }
6201 ++index;
6202 input_value >>= 1;
6203 }
6204 if( ret.empty()) ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(0)));
6205 return ret;
6206 }
6207
string_VkSemaphoreTypeKHR(VkSemaphoreTypeKHR input_value)6208 static inline const char* string_VkSemaphoreTypeKHR(VkSemaphoreTypeKHR input_value)
6209 {
6210 switch (input_value)
6211 {
6212 case VK_SEMAPHORE_TYPE_BINARY:
6213 return "VK_SEMAPHORE_TYPE_BINARY";
6214 case VK_SEMAPHORE_TYPE_TIMELINE:
6215 return "VK_SEMAPHORE_TYPE_TIMELINE";
6216 default:
6217 return "Unhandled VkSemaphoreTypeKHR";
6218 }
6219 }
6220
string_VkSemaphoreWaitFlagBitsKHR(VkSemaphoreWaitFlagBitsKHR input_value)6221 static inline const char* string_VkSemaphoreWaitFlagBitsKHR(VkSemaphoreWaitFlagBitsKHR input_value)
6222 {
6223 switch (input_value)
6224 {
6225 case VK_SEMAPHORE_WAIT_ANY_BIT:
6226 return "VK_SEMAPHORE_WAIT_ANY_BIT";
6227 default:
6228 return "Unhandled VkSemaphoreWaitFlagBitsKHR";
6229 }
6230 }
6231
string_VkSemaphoreWaitFlagsKHR(VkSemaphoreWaitFlagsKHR input_value)6232 static inline std::string string_VkSemaphoreWaitFlagsKHR(VkSemaphoreWaitFlagsKHR input_value)
6233 {
6234 std::string ret;
6235 int index = 0;
6236 while(input_value) {
6237 if (input_value & 1) {
6238 if( !ret.empty()) ret.append("|");
6239 ret.append(string_VkSemaphoreWaitFlagBitsKHR(static_cast<VkSemaphoreWaitFlagBitsKHR>(1U << index)));
6240 }
6241 ++index;
6242 input_value >>= 1;
6243 }
6244 if( ret.empty()) ret.append(string_VkSemaphoreWaitFlagBitsKHR(static_cast<VkSemaphoreWaitFlagBitsKHR>(0)));
6245 return ret;
6246 }
6247
string_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR input_value)6248 static inline const char* string_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR input_value)
6249 {
6250 switch (input_value)
6251 {
6252 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
6253 return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR";
6254 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
6255 return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR";
6256 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
6257 return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR";
6258 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
6259 return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR";
6260 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
6261 return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR";
6262 default:
6263 return "Unhandled VkFragmentShadingRateCombinerOpKHR";
6264 }
6265 }
6266
string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)6267 static inline const char* string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)
6268 {
6269 switch (input_value)
6270 {
6271 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
6272 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR";
6273 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
6274 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR";
6275 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
6276 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR";
6277 case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
6278 return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR";
6279 default:
6280 return "Unhandled VkPipelineExecutableStatisticFormatKHR";
6281 }
6282 }
6283
6284
6285 #ifdef VK_ENABLE_BETA_EXTENSIONS
6286
string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value)6287 static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value)
6288 {
6289 switch (input_value)
6290 {
6291 case VK_VIDEO_ENCODE_DEFAULT_KHR:
6292 return "VK_VIDEO_ENCODE_DEFAULT_KHR";
6293 case VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR:
6294 return "VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR";
6295 default:
6296 return "Unhandled VkVideoEncodeFlagBitsKHR";
6297 }
6298 }
6299
string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value)6300 static inline std::string string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value)
6301 {
6302 std::string ret;
6303 int index = 0;
6304 while(input_value) {
6305 if (input_value & 1) {
6306 if( !ret.empty()) ret.append("|");
6307 ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(1U << index)));
6308 }
6309 ++index;
6310 input_value >>= 1;
6311 }
6312 if( ret.empty()) ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(0)));
6313 return ret;
6314 }
6315 #endif // VK_ENABLE_BETA_EXTENSIONS
6316
6317
6318 #ifdef VK_ENABLE_BETA_EXTENSIONS
6319
string_VkVideoEncodeRateControlFlagBitsKHR(VkVideoEncodeRateControlFlagBitsKHR input_value)6320 static inline const char* string_VkVideoEncodeRateControlFlagBitsKHR(VkVideoEncodeRateControlFlagBitsKHR input_value)
6321 {
6322 switch (input_value)
6323 {
6324 case VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR:
6325 return "VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR";
6326 case VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR:
6327 return "VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR";
6328 default:
6329 return "Unhandled VkVideoEncodeRateControlFlagBitsKHR";
6330 }
6331 }
6332
string_VkVideoEncodeRateControlFlagsKHR(VkVideoEncodeRateControlFlagsKHR input_value)6333 static inline std::string string_VkVideoEncodeRateControlFlagsKHR(VkVideoEncodeRateControlFlagsKHR input_value)
6334 {
6335 std::string ret;
6336 int index = 0;
6337 while(input_value) {
6338 if (input_value & 1) {
6339 if( !ret.empty()) ret.append("|");
6340 ret.append(string_VkVideoEncodeRateControlFlagBitsKHR(static_cast<VkVideoEncodeRateControlFlagBitsKHR>(1U << index)));
6341 }
6342 ++index;
6343 input_value >>= 1;
6344 }
6345 if( ret.empty()) ret.append(string_VkVideoEncodeRateControlFlagBitsKHR(static_cast<VkVideoEncodeRateControlFlagBitsKHR>(0)));
6346 return ret;
6347 }
6348 #endif // VK_ENABLE_BETA_EXTENSIONS
6349
6350
6351 #ifdef VK_ENABLE_BETA_EXTENSIONS
6352
string_VkVideoEncodeRateControlModeFlagBitsKHR(VkVideoEncodeRateControlModeFlagBitsKHR input_value)6353 static inline const char* string_VkVideoEncodeRateControlModeFlagBitsKHR(VkVideoEncodeRateControlModeFlagBitsKHR input_value)
6354 {
6355 switch (input_value)
6356 {
6357 case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR:
6358 return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR";
6359 case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR:
6360 return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR";
6361 case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR:
6362 return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR";
6363 default:
6364 return "Unhandled VkVideoEncodeRateControlModeFlagBitsKHR";
6365 }
6366 }
6367
string_VkVideoEncodeRateControlModeFlagsKHR(VkVideoEncodeRateControlModeFlagsKHR input_value)6368 static inline std::string string_VkVideoEncodeRateControlModeFlagsKHR(VkVideoEncodeRateControlModeFlagsKHR input_value)
6369 {
6370 std::string ret;
6371 int index = 0;
6372 while(input_value) {
6373 if (input_value & 1) {
6374 if( !ret.empty()) ret.append("|");
6375 ret.append(string_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(1U << index)));
6376 }
6377 ++index;
6378 input_value >>= 1;
6379 }
6380 if( ret.empty()) ret.append(string_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(0)));
6381 return ret;
6382 }
6383 #endif // VK_ENABLE_BETA_EXTENSIONS
6384
string_VkPipelineStageFlagBits2KHR(uint64_t input_value)6385 static inline const char* string_VkPipelineStageFlagBits2KHR(uint64_t input_value)
6386 {
6387 switch (input_value)
6388 {
6389 case VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
6390 return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
6391 case VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR:
6392 return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR";
6393 case VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR:
6394 return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR";
6395 case VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR:
6396 return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR";
6397 case VK_PIPELINE_STAGE_2_BLIT_BIT_KHR:
6398 return "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR";
6399 case VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR:
6400 return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR";
6401 case VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR:
6402 return "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR";
6403 case VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR:
6404 return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR";
6405 case VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV:
6406 return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV";
6407 case VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR:
6408 return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR";
6409 case VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT:
6410 return "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
6411 case VK_PIPELINE_STAGE_2_COPY_BIT_KHR:
6412 return "VK_PIPELINE_STAGE_2_COPY_BIT_KHR";
6413 case VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR:
6414 return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR";
6415 case VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR:
6416 return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR";
6417 case VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
6418 return "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
6419 case VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR:
6420 return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR";
6421 case VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
6422 return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
6423 case VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR:
6424 return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR";
6425 case VK_PIPELINE_STAGE_2_HOST_BIT_KHR:
6426 return "VK_PIPELINE_STAGE_2_HOST_BIT_KHR";
6427 case VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR:
6428 return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR";
6429 case VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR:
6430 return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR";
6431 case VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV:
6432 return "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV";
6433 case VK_PIPELINE_STAGE_2_NONE_KHR:
6434 return "VK_PIPELINE_STAGE_2_NONE_KHR";
6435 case VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR:
6436 return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR";
6437 case VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR:
6438 return "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR";
6439 case VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR:
6440 return "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR";
6441 case VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI:
6442 return "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI";
6443 case VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV:
6444 return "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV";
6445 case VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR:
6446 return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR";
6447 case VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR:
6448 return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR";
6449 case VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR:
6450 return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR";
6451 case VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT:
6452 return "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT";
6453 case VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR:
6454 return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR";
6455 case VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR:
6456 return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR";
6457 case VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR:
6458 return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR";
6459 #ifdef VK_ENABLE_BETA_EXTENSIONS
6460 case VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR:
6461 return "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR";
6462 #endif // VK_ENABLE_BETA_EXTENSIONS
6463 #ifdef VK_ENABLE_BETA_EXTENSIONS
6464 case VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR:
6465 return "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR";
6466 #endif // VK_ENABLE_BETA_EXTENSIONS
6467 default:
6468 return "Unhandled VkPipelineStageFlagBits2KHR";
6469 }
6470 }
6471
string_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR input_value)6472 static inline std::string string_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR input_value)
6473 {
6474 std::string ret;
6475 int index = 0;
6476 while(input_value) {
6477 if (input_value & 1) {
6478 if( !ret.empty()) ret.append("|");
6479 ret.append(string_VkPipelineStageFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
6480 }
6481 ++index;
6482 input_value >>= 1;
6483 }
6484 if( ret.empty()) ret.append(string_VkPipelineStageFlagBits2KHR(static_cast<uint64_t>(0)));
6485 return ret;
6486 }
6487
string_VkAccessFlagBits2KHR(uint64_t input_value)6488 static inline const char* string_VkAccessFlagBits2KHR(uint64_t input_value)
6489 {
6490 switch (input_value)
6491 {
6492 case VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR:
6493 return "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR";
6494 case VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
6495 return "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
6496 case VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR:
6497 return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR";
6498 case VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
6499 return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
6500 case VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR:
6501 return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR";
6502 case VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV:
6503 return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV";
6504 case VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV:
6505 return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV";
6506 case VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT:
6507 return "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT";
6508 case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR:
6509 return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR";
6510 case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR:
6511 return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR";
6512 case VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
6513 return "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
6514 case VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
6515 return "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
6516 case VK_ACCESS_2_HOST_READ_BIT_KHR:
6517 return "VK_ACCESS_2_HOST_READ_BIT_KHR";
6518 case VK_ACCESS_2_HOST_WRITE_BIT_KHR:
6519 return "VK_ACCESS_2_HOST_WRITE_BIT_KHR";
6520 case VK_ACCESS_2_INDEX_READ_BIT_KHR:
6521 return "VK_ACCESS_2_INDEX_READ_BIT_KHR";
6522 case VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR:
6523 return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR";
6524 case VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR:
6525 return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR";
6526 case VK_ACCESS_2_MEMORY_READ_BIT_KHR:
6527 return "VK_ACCESS_2_MEMORY_READ_BIT_KHR";
6528 case VK_ACCESS_2_MEMORY_WRITE_BIT_KHR:
6529 return "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR";
6530 case VK_ACCESS_2_NONE_KHR:
6531 return "VK_ACCESS_2_NONE_KHR";
6532 case VK_ACCESS_2_SHADER_READ_BIT_KHR:
6533 return "VK_ACCESS_2_SHADER_READ_BIT_KHR";
6534 case VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR:
6535 return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR";
6536 case VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR:
6537 return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR";
6538 case VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR:
6539 return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR";
6540 case VK_ACCESS_2_SHADER_WRITE_BIT_KHR:
6541 return "VK_ACCESS_2_SHADER_WRITE_BIT_KHR";
6542 case VK_ACCESS_2_TRANSFER_READ_BIT_KHR:
6543 return "VK_ACCESS_2_TRANSFER_READ_BIT_KHR";
6544 case VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR:
6545 return "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR";
6546 case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
6547 return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
6548 case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
6549 return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
6550 case VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
6551 return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
6552 case VK_ACCESS_2_UNIFORM_READ_BIT_KHR:
6553 return "VK_ACCESS_2_UNIFORM_READ_BIT_KHR";
6554 case VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR:
6555 return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR";
6556 #ifdef VK_ENABLE_BETA_EXTENSIONS
6557 case VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR:
6558 return "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR";
6559 #endif // VK_ENABLE_BETA_EXTENSIONS
6560 #ifdef VK_ENABLE_BETA_EXTENSIONS
6561 case VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR:
6562 return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
6563 #endif // VK_ENABLE_BETA_EXTENSIONS
6564 #ifdef VK_ENABLE_BETA_EXTENSIONS
6565 case VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR:
6566 return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
6567 #endif // VK_ENABLE_BETA_EXTENSIONS
6568 #ifdef VK_ENABLE_BETA_EXTENSIONS
6569 case VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR:
6570 return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
6571 #endif // VK_ENABLE_BETA_EXTENSIONS
6572 default:
6573 return "Unhandled VkAccessFlagBits2KHR";
6574 }
6575 }
6576
string_VkAccessFlags2KHR(VkAccessFlags2KHR input_value)6577 static inline std::string string_VkAccessFlags2KHR(VkAccessFlags2KHR input_value)
6578 {
6579 std::string ret;
6580 int index = 0;
6581 while(input_value) {
6582 if (input_value & 1) {
6583 if( !ret.empty()) ret.append("|");
6584 ret.append(string_VkAccessFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
6585 }
6586 ++index;
6587 input_value >>= 1;
6588 }
6589 if( ret.empty()) ret.append(string_VkAccessFlagBits2KHR(static_cast<uint64_t>(0)));
6590 return ret;
6591 }
6592
string_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR input_value)6593 static inline const char* string_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR input_value)
6594 {
6595 switch (input_value)
6596 {
6597 case VK_SUBMIT_PROTECTED_BIT_KHR:
6598 return "VK_SUBMIT_PROTECTED_BIT_KHR";
6599 default:
6600 return "Unhandled VkSubmitFlagBitsKHR";
6601 }
6602 }
6603
string_VkSubmitFlagsKHR(VkSubmitFlagsKHR input_value)6604 static inline std::string string_VkSubmitFlagsKHR(VkSubmitFlagsKHR input_value)
6605 {
6606 std::string ret;
6607 int index = 0;
6608 while(input_value) {
6609 if (input_value & 1) {
6610 if( !ret.empty()) ret.append("|");
6611 ret.append(string_VkSubmitFlagBitsKHR(static_cast<VkSubmitFlagBitsKHR>(1U << index)));
6612 }
6613 ++index;
6614 input_value >>= 1;
6615 }
6616 if( ret.empty()) ret.append(string_VkSubmitFlagBitsKHR(static_cast<VkSubmitFlagBitsKHR>(0)));
6617 return ret;
6618 }
6619
string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)6620 static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)
6621 {
6622 switch (input_value)
6623 {
6624 case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
6625 return "VK_DEBUG_REPORT_DEBUG_BIT_EXT";
6626 case VK_DEBUG_REPORT_ERROR_BIT_EXT:
6627 return "VK_DEBUG_REPORT_ERROR_BIT_EXT";
6628 case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
6629 return "VK_DEBUG_REPORT_INFORMATION_BIT_EXT";
6630 case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
6631 return "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT";
6632 case VK_DEBUG_REPORT_WARNING_BIT_EXT:
6633 return "VK_DEBUG_REPORT_WARNING_BIT_EXT";
6634 default:
6635 return "Unhandled VkDebugReportFlagBitsEXT";
6636 }
6637 }
6638
string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value)6639 static inline std::string string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value)
6640 {
6641 std::string ret;
6642 int index = 0;
6643 while(input_value) {
6644 if (input_value & 1) {
6645 if( !ret.empty()) ret.append("|");
6646 ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(1U << index)));
6647 }
6648 ++index;
6649 input_value >>= 1;
6650 }
6651 if( ret.empty()) ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(0)));
6652 return ret;
6653 }
6654
string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)6655 static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)
6656 {
6657 switch (input_value)
6658 {
6659 case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT:
6660 return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT";
6661 case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT:
6662 return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT";
6663 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
6664 return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
6665 case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
6666 return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
6667 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
6668 return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
6669 case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
6670 return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
6671 case VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT:
6672 return "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT";
6673 case VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT:
6674 return "VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT";
6675 case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT:
6676 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT";
6677 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
6678 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
6679 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
6680 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
6681 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
6682 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
6683 case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT:
6684 return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT";
6685 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
6686 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
6687 case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
6688 return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
6689 case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:
6690 return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
6691 case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:
6692 return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
6693 case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
6694 return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
6695 case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
6696 return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
6697 case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
6698 return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
6699 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
6700 return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
6701 case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
6702 return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
6703 case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
6704 return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
6705 case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
6706 return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
6707 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
6708 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
6709 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
6710 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
6711 case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
6712 return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
6713 case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
6714 return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
6715 case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
6716 return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
6717 case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
6718 return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
6719 case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
6720 return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
6721 case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT:
6722 return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT";
6723 case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
6724 return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
6725 case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
6726 return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
6727 case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
6728 return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
6729 case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
6730 return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
6731 case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
6732 return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
6733 case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT:
6734 return "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT";
6735 default:
6736 return "Unhandled VkDebugReportObjectTypeEXT";
6737 }
6738 }
6739
string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)6740 static inline const char* string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)
6741 {
6742 switch (input_value)
6743 {
6744 case VK_RASTERIZATION_ORDER_RELAXED_AMD:
6745 return "VK_RASTERIZATION_ORDER_RELAXED_AMD";
6746 case VK_RASTERIZATION_ORDER_STRICT_AMD:
6747 return "VK_RASTERIZATION_ORDER_STRICT_AMD";
6748 default:
6749 return "Unhandled VkRasterizationOrderAMD";
6750 }
6751 }
6752
6753
6754 #ifdef VK_ENABLE_BETA_EXTENSIONS
6755
string_VkVideoEncodeH264CapabilitiesFlagBitsEXT(VkVideoEncodeH264CapabilitiesFlagBitsEXT input_value)6756 static inline const char* string_VkVideoEncodeH264CapabilitiesFlagBitsEXT(VkVideoEncodeH264CapabilitiesFlagBitsEXT input_value)
6757 {
6758 switch (input_value)
6759 {
6760 case VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT:
6761 return "VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT";
6762 case VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT:
6763 return "VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT";
6764 case VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT:
6765 return "VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT";
6766 case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT:
6767 return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT";
6768 case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT:
6769 return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT";
6770 case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT:
6771 return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT";
6772 case VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT:
6773 return "VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT";
6774 case VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT:
6775 return "VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT";
6776 case VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT:
6777 return "VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT";
6778 case VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT:
6779 return "VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT";
6780 case VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT:
6781 return "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT";
6782 default:
6783 return "Unhandled VkVideoEncodeH264CapabilitiesFlagBitsEXT";
6784 }
6785 }
6786
string_VkVideoEncodeH264CapabilitiesFlagsEXT(VkVideoEncodeH264CapabilitiesFlagsEXT input_value)6787 static inline std::string string_VkVideoEncodeH264CapabilitiesFlagsEXT(VkVideoEncodeH264CapabilitiesFlagsEXT input_value)
6788 {
6789 std::string ret;
6790 int index = 0;
6791 while(input_value) {
6792 if (input_value & 1) {
6793 if( !ret.empty()) ret.append("|");
6794 ret.append(string_VkVideoEncodeH264CapabilitiesFlagBitsEXT(static_cast<VkVideoEncodeH264CapabilitiesFlagBitsEXT>(1U << index)));
6795 }
6796 ++index;
6797 input_value >>= 1;
6798 }
6799 if( ret.empty()) ret.append(string_VkVideoEncodeH264CapabilitiesFlagBitsEXT(static_cast<VkVideoEncodeH264CapabilitiesFlagBitsEXT>(0)));
6800 return ret;
6801 }
6802 #endif // VK_ENABLE_BETA_EXTENSIONS
6803
6804
6805 #ifdef VK_ENABLE_BETA_EXTENSIONS
6806
string_VkVideoEncodeH264InputModeFlagBitsEXT(VkVideoEncodeH264InputModeFlagBitsEXT input_value)6807 static inline const char* string_VkVideoEncodeH264InputModeFlagBitsEXT(VkVideoEncodeH264InputModeFlagBitsEXT input_value)
6808 {
6809 switch (input_value)
6810 {
6811 case VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT:
6812 return "VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT";
6813 case VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT:
6814 return "VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT";
6815 case VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT:
6816 return "VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT";
6817 default:
6818 return "Unhandled VkVideoEncodeH264InputModeFlagBitsEXT";
6819 }
6820 }
6821
string_VkVideoEncodeH264InputModeFlagsEXT(VkVideoEncodeH264InputModeFlagsEXT input_value)6822 static inline std::string string_VkVideoEncodeH264InputModeFlagsEXT(VkVideoEncodeH264InputModeFlagsEXT input_value)
6823 {
6824 std::string ret;
6825 int index = 0;
6826 while(input_value) {
6827 if (input_value & 1) {
6828 if( !ret.empty()) ret.append("|");
6829 ret.append(string_VkVideoEncodeH264InputModeFlagBitsEXT(static_cast<VkVideoEncodeH264InputModeFlagBitsEXT>(1U << index)));
6830 }
6831 ++index;
6832 input_value >>= 1;
6833 }
6834 if( ret.empty()) ret.append(string_VkVideoEncodeH264InputModeFlagBitsEXT(static_cast<VkVideoEncodeH264InputModeFlagBitsEXT>(0)));
6835 return ret;
6836 }
6837 #endif // VK_ENABLE_BETA_EXTENSIONS
6838
6839
6840 #ifdef VK_ENABLE_BETA_EXTENSIONS
6841
string_VkVideoEncodeH264OutputModeFlagBitsEXT(VkVideoEncodeH264OutputModeFlagBitsEXT input_value)6842 static inline const char* string_VkVideoEncodeH264OutputModeFlagBitsEXT(VkVideoEncodeH264OutputModeFlagBitsEXT input_value)
6843 {
6844 switch (input_value)
6845 {
6846 case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT:
6847 return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT";
6848 case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT:
6849 return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT";
6850 case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT:
6851 return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT";
6852 default:
6853 return "Unhandled VkVideoEncodeH264OutputModeFlagBitsEXT";
6854 }
6855 }
6856
string_VkVideoEncodeH264OutputModeFlagsEXT(VkVideoEncodeH264OutputModeFlagsEXT input_value)6857 static inline std::string string_VkVideoEncodeH264OutputModeFlagsEXT(VkVideoEncodeH264OutputModeFlagsEXT input_value)
6858 {
6859 std::string ret;
6860 int index = 0;
6861 while(input_value) {
6862 if (input_value & 1) {
6863 if( !ret.empty()) ret.append("|");
6864 ret.append(string_VkVideoEncodeH264OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH264OutputModeFlagBitsEXT>(1U << index)));
6865 }
6866 ++index;
6867 input_value >>= 1;
6868 }
6869 if( ret.empty()) ret.append(string_VkVideoEncodeH264OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH264OutputModeFlagBitsEXT>(0)));
6870 return ret;
6871 }
6872 #endif // VK_ENABLE_BETA_EXTENSIONS
6873
6874
6875 #ifdef VK_ENABLE_BETA_EXTENSIONS
6876
string_VkVideoEncodeH264CreateFlagBitsEXT(VkVideoEncodeH264CreateFlagBitsEXT input_value)6877 static inline const char* string_VkVideoEncodeH264CreateFlagBitsEXT(VkVideoEncodeH264CreateFlagBitsEXT input_value)
6878 {
6879 switch (input_value)
6880 {
6881 case VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT:
6882 return "VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT";
6883 case VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT:
6884 return "VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT";
6885 default:
6886 return "Unhandled VkVideoEncodeH264CreateFlagBitsEXT";
6887 }
6888 }
6889
string_VkVideoEncodeH264CreateFlagsEXT(VkVideoEncodeH264CreateFlagsEXT input_value)6890 static inline std::string string_VkVideoEncodeH264CreateFlagsEXT(VkVideoEncodeH264CreateFlagsEXT input_value)
6891 {
6892 std::string ret;
6893 int index = 0;
6894 while(input_value) {
6895 if (input_value & 1) {
6896 if( !ret.empty()) ret.append("|");
6897 ret.append(string_VkVideoEncodeH264CreateFlagBitsEXT(static_cast<VkVideoEncodeH264CreateFlagBitsEXT>(1U << index)));
6898 }
6899 ++index;
6900 input_value >>= 1;
6901 }
6902 if( ret.empty()) ret.append(string_VkVideoEncodeH264CreateFlagBitsEXT(static_cast<VkVideoEncodeH264CreateFlagBitsEXT>(0)));
6903 return ret;
6904 }
6905 #endif // VK_ENABLE_BETA_EXTENSIONS
6906
6907
6908 #ifdef VK_ENABLE_BETA_EXTENSIONS
6909
string_VkVideoDecodeH264FieldLayoutFlagBitsEXT(VkVideoDecodeH264FieldLayoutFlagBitsEXT input_value)6910 static inline const char* string_VkVideoDecodeH264FieldLayoutFlagBitsEXT(VkVideoDecodeH264FieldLayoutFlagBitsEXT input_value)
6911 {
6912 switch (input_value)
6913 {
6914 case VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT:
6915 return "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT";
6916 case VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT:
6917 return "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT";
6918 case VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT:
6919 return "VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT";
6920 default:
6921 return "Unhandled VkVideoDecodeH264FieldLayoutFlagBitsEXT";
6922 }
6923 }
6924
string_VkVideoDecodeH264FieldLayoutFlagsEXT(VkVideoDecodeH264FieldLayoutFlagsEXT input_value)6925 static inline std::string string_VkVideoDecodeH264FieldLayoutFlagsEXT(VkVideoDecodeH264FieldLayoutFlagsEXT input_value)
6926 {
6927 std::string ret;
6928 int index = 0;
6929 while(input_value) {
6930 if (input_value & 1) {
6931 if( !ret.empty()) ret.append("|");
6932 ret.append(string_VkVideoDecodeH264FieldLayoutFlagBitsEXT(static_cast<VkVideoDecodeH264FieldLayoutFlagBitsEXT>(1U << index)));
6933 }
6934 ++index;
6935 input_value >>= 1;
6936 }
6937 if( ret.empty()) ret.append(string_VkVideoDecodeH264FieldLayoutFlagBitsEXT(static_cast<VkVideoDecodeH264FieldLayoutFlagBitsEXT>(0)));
6938 return ret;
6939 }
6940 #endif // VK_ENABLE_BETA_EXTENSIONS
6941
string_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD input_value)6942 static inline const char* string_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD input_value)
6943 {
6944 switch (input_value)
6945 {
6946 case VK_SHADER_INFO_TYPE_BINARY_AMD:
6947 return "VK_SHADER_INFO_TYPE_BINARY_AMD";
6948 case VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD:
6949 return "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD";
6950 case VK_SHADER_INFO_TYPE_STATISTICS_AMD:
6951 return "VK_SHADER_INFO_TYPE_STATISTICS_AMD";
6952 default:
6953 return "Unhandled VkShaderInfoTypeAMD";
6954 }
6955 }
6956
string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)6957 static inline const char* string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)
6958 {
6959 switch (input_value)
6960 {
6961 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV:
6962 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV";
6963 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV:
6964 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV";
6965 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV:
6966 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV";
6967 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV:
6968 return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV";
6969 default:
6970 return "Unhandled VkExternalMemoryHandleTypeFlagBitsNV";
6971 }
6972 }
6973
string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value)6974 static inline std::string string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value)
6975 {
6976 std::string ret;
6977 int index = 0;
6978 while(input_value) {
6979 if (input_value & 1) {
6980 if( !ret.empty()) ret.append("|");
6981 ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(1U << index)));
6982 }
6983 ++index;
6984 input_value >>= 1;
6985 }
6986 if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(0)));
6987 return ret;
6988 }
6989
string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)6990 static inline const char* string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)
6991 {
6992 switch (input_value)
6993 {
6994 case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV:
6995 return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV";
6996 case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV:
6997 return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV";
6998 case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV:
6999 return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV";
7000 default:
7001 return "Unhandled VkExternalMemoryFeatureFlagBitsNV";
7002 }
7003 }
7004
string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value)7005 static inline std::string string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value)
7006 {
7007 std::string ret;
7008 int index = 0;
7009 while(input_value) {
7010 if (input_value & 1) {
7011 if( !ret.empty()) ret.append("|");
7012 ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(1U << index)));
7013 }
7014 ++index;
7015 input_value >>= 1;
7016 }
7017 if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(0)));
7018 return ret;
7019 }
7020
string_VkValidationCheckEXT(VkValidationCheckEXT input_value)7021 static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input_value)
7022 {
7023 switch (input_value)
7024 {
7025 case VK_VALIDATION_CHECK_ALL_EXT:
7026 return "VK_VALIDATION_CHECK_ALL_EXT";
7027 case VK_VALIDATION_CHECK_SHADERS_EXT:
7028 return "VK_VALIDATION_CHECK_SHADERS_EXT";
7029 default:
7030 return "Unhandled VkValidationCheckEXT";
7031 }
7032 }
7033
string_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT input_value)7034 static inline const char* string_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT input_value)
7035 {
7036 switch (input_value)
7037 {
7038 case VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT:
7039 return "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT";
7040 default:
7041 return "Unhandled VkConditionalRenderingFlagBitsEXT";
7042 }
7043 }
7044
string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value)7045 static inline std::string string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value)
7046 {
7047 std::string ret;
7048 int index = 0;
7049 while(input_value) {
7050 if (input_value & 1) {
7051 if( !ret.empty()) ret.append("|");
7052 ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(1U << index)));
7053 }
7054 ++index;
7055 input_value >>= 1;
7056 }
7057 if( ret.empty()) ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(0)));
7058 return ret;
7059 }
7060
string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)7061 static inline const char* string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)
7062 {
7063 switch (input_value)
7064 {
7065 case VK_SURFACE_COUNTER_VBLANK_BIT_EXT:
7066 return "VK_SURFACE_COUNTER_VBLANK_BIT_EXT";
7067 default:
7068 return "Unhandled VkSurfaceCounterFlagBitsEXT";
7069 }
7070 }
7071
string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value)7072 static inline std::string string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value)
7073 {
7074 std::string ret;
7075 int index = 0;
7076 while(input_value) {
7077 if (input_value & 1) {
7078 if( !ret.empty()) ret.append("|");
7079 ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(1U << index)));
7080 }
7081 ++index;
7082 input_value >>= 1;
7083 }
7084 if( ret.empty()) ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(0)));
7085 return ret;
7086 }
7087
string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)7088 static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)
7089 {
7090 switch (input_value)
7091 {
7092 case VK_DISPLAY_POWER_STATE_OFF_EXT:
7093 return "VK_DISPLAY_POWER_STATE_OFF_EXT";
7094 case VK_DISPLAY_POWER_STATE_ON_EXT:
7095 return "VK_DISPLAY_POWER_STATE_ON_EXT";
7096 case VK_DISPLAY_POWER_STATE_SUSPEND_EXT:
7097 return "VK_DISPLAY_POWER_STATE_SUSPEND_EXT";
7098 default:
7099 return "Unhandled VkDisplayPowerStateEXT";
7100 }
7101 }
7102
string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)7103 static inline const char* string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)
7104 {
7105 switch (input_value)
7106 {
7107 case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT:
7108 return "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT";
7109 default:
7110 return "Unhandled VkDeviceEventTypeEXT";
7111 }
7112 }
7113
string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)7114 static inline const char* string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)
7115 {
7116 switch (input_value)
7117 {
7118 case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT:
7119 return "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT";
7120 default:
7121 return "Unhandled VkDisplayEventTypeEXT";
7122 }
7123 }
7124
string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)7125 static inline const char* string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)
7126 {
7127 switch (input_value)
7128 {
7129 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV:
7130 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV";
7131 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV:
7132 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV";
7133 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV:
7134 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV";
7135 case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV:
7136 return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV";
7137 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV:
7138 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV";
7139 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV:
7140 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV";
7141 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV:
7142 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV";
7143 case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV:
7144 return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV";
7145 default:
7146 return "Unhandled VkViewportCoordinateSwizzleNV";
7147 }
7148 }
7149
string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)7150 static inline const char* string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)
7151 {
7152 switch (input_value)
7153 {
7154 case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT:
7155 return "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT";
7156 case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT:
7157 return "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT";
7158 default:
7159 return "Unhandled VkDiscardRectangleModeEXT";
7160 }
7161 }
7162
string_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT input_value)7163 static inline const char* string_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT input_value)
7164 {
7165 switch (input_value)
7166 {
7167 case VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT:
7168 return "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT";
7169 case VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT:
7170 return "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT";
7171 case VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT:
7172 return "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT";
7173 default:
7174 return "Unhandled VkConservativeRasterizationModeEXT";
7175 }
7176 }
7177
string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT input_value)7178 static inline const char* string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT input_value)
7179 {
7180 switch (input_value)
7181 {
7182 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
7183 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT";
7184 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
7185 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT";
7186 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
7187 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT";
7188 case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
7189 return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT";
7190 default:
7191 return "Unhandled VkDebugUtilsMessageSeverityFlagBitsEXT";
7192 }
7193 }
7194
string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value)7195 static inline std::string string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value)
7196 {
7197 std::string ret;
7198 int index = 0;
7199 while(input_value) {
7200 if (input_value & 1) {
7201 if( !ret.empty()) ret.append("|");
7202 ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(1U << index)));
7203 }
7204 ++index;
7205 input_value >>= 1;
7206 }
7207 if( ret.empty()) ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(0)));
7208 return ret;
7209 }
7210
string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT input_value)7211 static inline const char* string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT input_value)
7212 {
7213 switch (input_value)
7214 {
7215 case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
7216 return "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT";
7217 case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
7218 return "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT";
7219 case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
7220 return "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT";
7221 default:
7222 return "Unhandled VkDebugUtilsMessageTypeFlagBitsEXT";
7223 }
7224 }
7225
string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value)7226 static inline std::string string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value)
7227 {
7228 std::string ret;
7229 int index = 0;
7230 while(input_value) {
7231 if (input_value & 1) {
7232 if( !ret.empty()) ret.append("|");
7233 ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(1U << index)));
7234 }
7235 ++index;
7236 input_value >>= 1;
7237 }
7238 if( ret.empty()) ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(0)));
7239 return ret;
7240 }
7241
string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)7242 static inline const char* string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)
7243 {
7244 switch (input_value)
7245 {
7246 case VK_SAMPLER_REDUCTION_MODE_MAX:
7247 return "VK_SAMPLER_REDUCTION_MODE_MAX";
7248 case VK_SAMPLER_REDUCTION_MODE_MIN:
7249 return "VK_SAMPLER_REDUCTION_MODE_MIN";
7250 case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
7251 return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE";
7252 default:
7253 return "Unhandled VkSamplerReductionModeEXT";
7254 }
7255 }
7256
string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)7257 static inline const char* string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)
7258 {
7259 switch (input_value)
7260 {
7261 case VK_BLEND_OVERLAP_CONJOINT_EXT:
7262 return "VK_BLEND_OVERLAP_CONJOINT_EXT";
7263 case VK_BLEND_OVERLAP_DISJOINT_EXT:
7264 return "VK_BLEND_OVERLAP_DISJOINT_EXT";
7265 case VK_BLEND_OVERLAP_UNCORRELATED_EXT:
7266 return "VK_BLEND_OVERLAP_UNCORRELATED_EXT";
7267 default:
7268 return "Unhandled VkBlendOverlapEXT";
7269 }
7270 }
7271
string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)7272 static inline const char* string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)
7273 {
7274 switch (input_value)
7275 {
7276 case VK_COVERAGE_MODULATION_MODE_ALPHA_NV:
7277 return "VK_COVERAGE_MODULATION_MODE_ALPHA_NV";
7278 case VK_COVERAGE_MODULATION_MODE_NONE_NV:
7279 return "VK_COVERAGE_MODULATION_MODE_NONE_NV";
7280 case VK_COVERAGE_MODULATION_MODE_RGBA_NV:
7281 return "VK_COVERAGE_MODULATION_MODE_RGBA_NV";
7282 case VK_COVERAGE_MODULATION_MODE_RGB_NV:
7283 return "VK_COVERAGE_MODULATION_MODE_RGB_NV";
7284 default:
7285 return "Unhandled VkCoverageModulationModeNV";
7286 }
7287 }
7288
string_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT input_value)7289 static inline const char* string_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT input_value)
7290 {
7291 switch (input_value)
7292 {
7293 case VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT:
7294 return "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT";
7295 default:
7296 return "Unhandled VkValidationCacheHeaderVersionEXT";
7297 }
7298 }
7299
string_VkDescriptorBindingFlagBitsEXT(VkDescriptorBindingFlagBitsEXT input_value)7300 static inline const char* string_VkDescriptorBindingFlagBitsEXT(VkDescriptorBindingFlagBitsEXT input_value)
7301 {
7302 switch (input_value)
7303 {
7304 case VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT:
7305 return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT";
7306 case VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT:
7307 return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT";
7308 case VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT:
7309 return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT";
7310 case VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT:
7311 return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT";
7312 default:
7313 return "Unhandled VkDescriptorBindingFlagBitsEXT";
7314 }
7315 }
7316
string_VkDescriptorBindingFlagsEXT(VkDescriptorBindingFlagsEXT input_value)7317 static inline std::string string_VkDescriptorBindingFlagsEXT(VkDescriptorBindingFlagsEXT input_value)
7318 {
7319 std::string ret;
7320 int index = 0;
7321 while(input_value) {
7322 if (input_value & 1) {
7323 if( !ret.empty()) ret.append("|");
7324 ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(1U << index)));
7325 }
7326 ++index;
7327 input_value >>= 1;
7328 }
7329 if( ret.empty()) ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(0)));
7330 return ret;
7331 }
7332
string_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV input_value)7333 static inline const char* string_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV input_value)
7334 {
7335 switch (input_value)
7336 {
7337 case VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV:
7338 return "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV";
7339 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV:
7340 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV";
7341 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV:
7342 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV";
7343 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV:
7344 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV";
7345 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV:
7346 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV";
7347 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV:
7348 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV";
7349 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV:
7350 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV";
7351 case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV:
7352 return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV";
7353 case VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV:
7354 return "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV";
7355 case VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV:
7356 return "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV";
7357 case VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV:
7358 return "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV";
7359 case VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV:
7360 return "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV";
7361 default:
7362 return "Unhandled VkShadingRatePaletteEntryNV";
7363 }
7364 }
7365
string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV input_value)7366 static inline const char* string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV input_value)
7367 {
7368 switch (input_value)
7369 {
7370 case VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV:
7371 return "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV";
7372 case VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV:
7373 return "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV";
7374 case VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV:
7375 return "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV";
7376 case VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV:
7377 return "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV";
7378 default:
7379 return "Unhandled VkCoarseSampleOrderTypeNV";
7380 }
7381 }
7382
string_VkRayTracingShaderGroupTypeKHR(VkRayTracingShaderGroupTypeKHR input_value)7383 static inline const char* string_VkRayTracingShaderGroupTypeKHR(VkRayTracingShaderGroupTypeKHR input_value)
7384 {
7385 switch (input_value)
7386 {
7387 case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
7388 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR";
7389 case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
7390 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR";
7391 case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
7392 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR";
7393 default:
7394 return "Unhandled VkRayTracingShaderGroupTypeKHR";
7395 }
7396 }
7397
string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)7398 static inline const char* string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)
7399 {
7400 switch (input_value)
7401 {
7402 case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
7403 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR";
7404 case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
7405 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR";
7406 case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
7407 return "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR";
7408 default:
7409 return "Unhandled VkRayTracingShaderGroupTypeNV";
7410 }
7411 }
7412
string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value)7413 static inline const char* string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value)
7414 {
7415 switch (input_value)
7416 {
7417 case VK_GEOMETRY_TYPE_AABBS_KHR:
7418 return "VK_GEOMETRY_TYPE_AABBS_KHR";
7419 case VK_GEOMETRY_TYPE_INSTANCES_KHR:
7420 return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
7421 case VK_GEOMETRY_TYPE_TRIANGLES_KHR:
7422 return "VK_GEOMETRY_TYPE_TRIANGLES_KHR";
7423 default:
7424 return "Unhandled VkGeometryTypeKHR";
7425 }
7426 }
7427
string_VkGeometryTypeNV(VkGeometryTypeNV input_value)7428 static inline const char* string_VkGeometryTypeNV(VkGeometryTypeNV input_value)
7429 {
7430 switch (input_value)
7431 {
7432 case VK_GEOMETRY_TYPE_AABBS_KHR:
7433 return "VK_GEOMETRY_TYPE_AABBS_KHR";
7434 case VK_GEOMETRY_TYPE_INSTANCES_KHR:
7435 return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
7436 case VK_GEOMETRY_TYPE_TRIANGLES_KHR:
7437 return "VK_GEOMETRY_TYPE_TRIANGLES_KHR";
7438 default:
7439 return "Unhandled VkGeometryTypeNV";
7440 }
7441 }
7442
string_VkAccelerationStructureTypeKHR(VkAccelerationStructureTypeKHR input_value)7443 static inline const char* string_VkAccelerationStructureTypeKHR(VkAccelerationStructureTypeKHR input_value)
7444 {
7445 switch (input_value)
7446 {
7447 case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR:
7448 return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR";
7449 case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR:
7450 return "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR";
7451 case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR:
7452 return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR";
7453 default:
7454 return "Unhandled VkAccelerationStructureTypeKHR";
7455 }
7456 }
7457
string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)7458 static inline const char* string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)
7459 {
7460 switch (input_value)
7461 {
7462 case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR:
7463 return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR";
7464 case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR:
7465 return "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR";
7466 case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR:
7467 return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR";
7468 default:
7469 return "Unhandled VkAccelerationStructureTypeNV";
7470 }
7471 }
7472
string_VkGeometryFlagBitsKHR(VkGeometryFlagBitsKHR input_value)7473 static inline const char* string_VkGeometryFlagBitsKHR(VkGeometryFlagBitsKHR input_value)
7474 {
7475 switch (input_value)
7476 {
7477 case VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR:
7478 return "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR";
7479 case VK_GEOMETRY_OPAQUE_BIT_KHR:
7480 return "VK_GEOMETRY_OPAQUE_BIT_KHR";
7481 default:
7482 return "Unhandled VkGeometryFlagBitsKHR";
7483 }
7484 }
7485
string_VkGeometryFlagsKHR(VkGeometryFlagsKHR input_value)7486 static inline std::string string_VkGeometryFlagsKHR(VkGeometryFlagsKHR input_value)
7487 {
7488 std::string ret;
7489 int index = 0;
7490 while(input_value) {
7491 if (input_value & 1) {
7492 if( !ret.empty()) ret.append("|");
7493 ret.append(string_VkGeometryFlagBitsKHR(static_cast<VkGeometryFlagBitsKHR>(1U << index)));
7494 }
7495 ++index;
7496 input_value >>= 1;
7497 }
7498 if( ret.empty()) ret.append(string_VkGeometryFlagBitsKHR(static_cast<VkGeometryFlagBitsKHR>(0)));
7499 return ret;
7500 }
7501
string_VkGeometryFlagBitsNV(VkGeometryFlagBitsNV input_value)7502 static inline const char* string_VkGeometryFlagBitsNV(VkGeometryFlagBitsNV input_value)
7503 {
7504 switch (input_value)
7505 {
7506 case VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR:
7507 return "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR";
7508 case VK_GEOMETRY_OPAQUE_BIT_KHR:
7509 return "VK_GEOMETRY_OPAQUE_BIT_KHR";
7510 default:
7511 return "Unhandled VkGeometryFlagBitsNV";
7512 }
7513 }
7514
string_VkGeometryFlagsNV(VkGeometryFlagsNV input_value)7515 static inline std::string string_VkGeometryFlagsNV(VkGeometryFlagsNV input_value)
7516 {
7517 std::string ret;
7518 int index = 0;
7519 while(input_value) {
7520 if (input_value & 1) {
7521 if( !ret.empty()) ret.append("|");
7522 ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(1U << index)));
7523 }
7524 ++index;
7525 input_value >>= 1;
7526 }
7527 if( ret.empty()) ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(0)));
7528 return ret;
7529 }
7530
string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanceFlagBitsKHR input_value)7531 static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanceFlagBitsKHR input_value)
7532 {
7533 switch (input_value)
7534 {
7535 case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR:
7536 return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
7537 case VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR:
7538 return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
7539 case VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR:
7540 return "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR";
7541 case VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR:
7542 return "VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR";
7543 default:
7544 return "Unhandled VkGeometryInstanceFlagBitsKHR";
7545 }
7546 }
7547
string_VkGeometryInstanceFlagsKHR(VkGeometryInstanceFlagsKHR input_value)7548 static inline std::string string_VkGeometryInstanceFlagsKHR(VkGeometryInstanceFlagsKHR input_value)
7549 {
7550 std::string ret;
7551 int index = 0;
7552 while(input_value) {
7553 if (input_value & 1) {
7554 if( !ret.empty()) ret.append("|");
7555 ret.append(string_VkGeometryInstanceFlagBitsKHR(static_cast<VkGeometryInstanceFlagBitsKHR>(1U << index)));
7556 }
7557 ++index;
7558 input_value >>= 1;
7559 }
7560 if( ret.empty()) ret.append(string_VkGeometryInstanceFlagBitsKHR(static_cast<VkGeometryInstanceFlagBitsKHR>(0)));
7561 return ret;
7562 }
7563
string_VkGeometryInstanceFlagBitsNV(VkGeometryInstanceFlagBitsNV input_value)7564 static inline const char* string_VkGeometryInstanceFlagBitsNV(VkGeometryInstanceFlagBitsNV input_value)
7565 {
7566 switch (input_value)
7567 {
7568 case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR:
7569 return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
7570 case VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR:
7571 return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
7572 case VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR:
7573 return "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR";
7574 case VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR:
7575 return "VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR";
7576 default:
7577 return "Unhandled VkGeometryInstanceFlagBitsNV";
7578 }
7579 }
7580
string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFlagsNV input_value)7581 static inline std::string string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFlagsNV input_value)
7582 {
7583 std::string ret;
7584 int index = 0;
7585 while(input_value) {
7586 if (input_value & 1) {
7587 if( !ret.empty()) ret.append("|");
7588 ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(1U << index)));
7589 }
7590 ++index;
7591 input_value >>= 1;
7592 }
7593 if( ret.empty()) ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(0)));
7594 return ret;
7595 }
7596
string_VkBuildAccelerationStructureFlagBitsKHR(VkBuildAccelerationStructureFlagBitsKHR input_value)7597 static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuildAccelerationStructureFlagBitsKHR input_value)
7598 {
7599 switch (input_value)
7600 {
7601 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR:
7602 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR";
7603 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR:
7604 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR";
7605 case VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR:
7606 return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
7607 case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV:
7608 return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
7609 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR:
7610 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR";
7611 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR:
7612 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR";
7613 default:
7614 return "Unhandled VkBuildAccelerationStructureFlagBitsKHR";
7615 }
7616 }
7617
string_VkBuildAccelerationStructureFlagsKHR(VkBuildAccelerationStructureFlagsKHR input_value)7618 static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAccelerationStructureFlagsKHR input_value)
7619 {
7620 std::string ret;
7621 int index = 0;
7622 while(input_value) {
7623 if (input_value & 1) {
7624 if( !ret.empty()) ret.append("|");
7625 ret.append(string_VkBuildAccelerationStructureFlagBitsKHR(static_cast<VkBuildAccelerationStructureFlagBitsKHR>(1U << index)));
7626 }
7627 ++index;
7628 input_value >>= 1;
7629 }
7630 if( ret.empty()) ret.append(string_VkBuildAccelerationStructureFlagBitsKHR(static_cast<VkBuildAccelerationStructureFlagBitsKHR>(0)));
7631 return ret;
7632 }
7633
string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)7634 static inline const char* string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)
7635 {
7636 switch (input_value)
7637 {
7638 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR:
7639 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR";
7640 case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR:
7641 return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR";
7642 case VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR:
7643 return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
7644 case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV:
7645 return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
7646 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR:
7647 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR";
7648 case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR:
7649 return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR";
7650 default:
7651 return "Unhandled VkBuildAccelerationStructureFlagBitsNV";
7652 }
7653 }
7654
string_VkBuildAccelerationStructureFlagsNV(VkBuildAccelerationStructureFlagsNV input_value)7655 static inline std::string string_VkBuildAccelerationStructureFlagsNV(VkBuildAccelerationStructureFlagsNV input_value)
7656 {
7657 std::string ret;
7658 int index = 0;
7659 while(input_value) {
7660 if (input_value & 1) {
7661 if( !ret.empty()) ret.append("|");
7662 ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(1U << index)));
7663 }
7664 ++index;
7665 input_value >>= 1;
7666 }
7667 if( ret.empty()) ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(0)));
7668 return ret;
7669 }
7670
string_VkCopyAccelerationStructureModeKHR(VkCopyAccelerationStructureModeKHR input_value)7671 static inline const char* string_VkCopyAccelerationStructureModeKHR(VkCopyAccelerationStructureModeKHR input_value)
7672 {
7673 switch (input_value)
7674 {
7675 case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR:
7676 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR";
7677 case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR:
7678 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR";
7679 case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR:
7680 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR";
7681 case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR:
7682 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR";
7683 default:
7684 return "Unhandled VkCopyAccelerationStructureModeKHR";
7685 }
7686 }
7687
string_VkCopyAccelerationStructureModeNV(VkCopyAccelerationStructureModeNV input_value)7688 static inline const char* string_VkCopyAccelerationStructureModeNV(VkCopyAccelerationStructureModeNV input_value)
7689 {
7690 switch (input_value)
7691 {
7692 case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR:
7693 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR";
7694 case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR:
7695 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR";
7696 case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR:
7697 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR";
7698 case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR:
7699 return "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR";
7700 default:
7701 return "Unhandled VkCopyAccelerationStructureModeNV";
7702 }
7703 }
7704
string_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV input_value)7705 static inline const char* string_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV input_value)
7706 {
7707 switch (input_value)
7708 {
7709 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV:
7710 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV";
7711 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV:
7712 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV";
7713 case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV:
7714 return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV";
7715 default:
7716 return "Unhandled VkAccelerationStructureMemoryRequirementsTypeNV";
7717 }
7718 }
7719
string_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT input_value)7720 static inline const char* string_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT input_value)
7721 {
7722 switch (input_value)
7723 {
7724 case VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT:
7725 return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT";
7726 case VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT:
7727 return "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT";
7728 case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT:
7729 return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT";
7730 case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT:
7731 return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT";
7732 default:
7733 return "Unhandled VkQueueGlobalPriorityEXT";
7734 }
7735 }
7736
string_VkTimeDomainEXT(VkTimeDomainEXT input_value)7737 static inline const char* string_VkTimeDomainEXT(VkTimeDomainEXT input_value)
7738 {
7739 switch (input_value)
7740 {
7741 case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT:
7742 return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT";
7743 case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT:
7744 return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT";
7745 case VK_TIME_DOMAIN_DEVICE_EXT:
7746 return "VK_TIME_DOMAIN_DEVICE_EXT";
7747 case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT:
7748 return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT";
7749 default:
7750 return "Unhandled VkTimeDomainEXT";
7751 }
7752 }
7753
string_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD input_value)7754 static inline const char* string_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD input_value)
7755 {
7756 switch (input_value)
7757 {
7758 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD:
7759 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD";
7760 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD:
7761 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD";
7762 case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD:
7763 return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD";
7764 default:
7765 return "Unhandled VkMemoryOverallocationBehaviorAMD";
7766 }
7767 }
7768
string_VkPipelineCreationFeedbackFlagBitsEXT(VkPipelineCreationFeedbackFlagBitsEXT input_value)7769 static inline const char* string_VkPipelineCreationFeedbackFlagBitsEXT(VkPipelineCreationFeedbackFlagBitsEXT input_value)
7770 {
7771 switch (input_value)
7772 {
7773 case VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT:
7774 return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT";
7775 case VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT:
7776 return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT";
7777 case VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT:
7778 return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT";
7779 default:
7780 return "Unhandled VkPipelineCreationFeedbackFlagBitsEXT";
7781 }
7782 }
7783
string_VkPipelineCreationFeedbackFlagsEXT(VkPipelineCreationFeedbackFlagsEXT input_value)7784 static inline std::string string_VkPipelineCreationFeedbackFlagsEXT(VkPipelineCreationFeedbackFlagsEXT input_value)
7785 {
7786 std::string ret;
7787 int index = 0;
7788 while(input_value) {
7789 if (input_value & 1) {
7790 if( !ret.empty()) ret.append("|");
7791 ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(1U << index)));
7792 }
7793 ++index;
7794 input_value >>= 1;
7795 }
7796 if( ret.empty()) ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(0)));
7797 return ret;
7798 }
7799
string_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL input_value)7800 static inline const char* string_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL input_value)
7801 {
7802 switch (input_value)
7803 {
7804 case VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL:
7805 return "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL";
7806 default:
7807 return "Unhandled VkPerformanceConfigurationTypeINTEL";
7808 }
7809 }
7810
string_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL input_value)7811 static inline const char* string_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL input_value)
7812 {
7813 switch (input_value)
7814 {
7815 case VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL:
7816 return "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL";
7817 default:
7818 return "Unhandled VkQueryPoolSamplingModeINTEL";
7819 }
7820 }
7821
string_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL input_value)7822 static inline const char* string_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL input_value)
7823 {
7824 switch (input_value)
7825 {
7826 case VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL:
7827 return "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL";
7828 case VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL:
7829 return "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL";
7830 default:
7831 return "Unhandled VkPerformanceOverrideTypeINTEL";
7832 }
7833 }
7834
string_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL input_value)7835 static inline const char* string_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL input_value)
7836 {
7837 switch (input_value)
7838 {
7839 case VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL:
7840 return "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL";
7841 case VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL:
7842 return "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL";
7843 default:
7844 return "Unhandled VkPerformanceParameterTypeINTEL";
7845 }
7846 }
7847
string_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL input_value)7848 static inline const char* string_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL input_value)
7849 {
7850 switch (input_value)
7851 {
7852 case VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL:
7853 return "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL";
7854 case VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL:
7855 return "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL";
7856 case VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL:
7857 return "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL";
7858 case VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL:
7859 return "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL";
7860 case VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL:
7861 return "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL";
7862 default:
7863 return "Unhandled VkPerformanceValueTypeINTEL";
7864 }
7865 }
7866
string_VkToolPurposeFlagBitsEXT(VkToolPurposeFlagBitsEXT input_value)7867 static inline const char* string_VkToolPurposeFlagBitsEXT(VkToolPurposeFlagBitsEXT input_value)
7868 {
7869 switch (input_value)
7870 {
7871 case VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT:
7872 return "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT";
7873 case VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT:
7874 return "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT";
7875 case VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT:
7876 return "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT";
7877 case VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT:
7878 return "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT";
7879 case VK_TOOL_PURPOSE_PROFILING_BIT_EXT:
7880 return "VK_TOOL_PURPOSE_PROFILING_BIT_EXT";
7881 case VK_TOOL_PURPOSE_TRACING_BIT_EXT:
7882 return "VK_TOOL_PURPOSE_TRACING_BIT_EXT";
7883 case VK_TOOL_PURPOSE_VALIDATION_BIT_EXT:
7884 return "VK_TOOL_PURPOSE_VALIDATION_BIT_EXT";
7885 default:
7886 return "Unhandled VkToolPurposeFlagBitsEXT";
7887 }
7888 }
7889
string_VkToolPurposeFlagsEXT(VkToolPurposeFlagsEXT input_value)7890 static inline std::string string_VkToolPurposeFlagsEXT(VkToolPurposeFlagsEXT input_value)
7891 {
7892 std::string ret;
7893 int index = 0;
7894 while(input_value) {
7895 if (input_value & 1) {
7896 if( !ret.empty()) ret.append("|");
7897 ret.append(string_VkToolPurposeFlagBitsEXT(static_cast<VkToolPurposeFlagBitsEXT>(1U << index)));
7898 }
7899 ++index;
7900 input_value >>= 1;
7901 }
7902 if( ret.empty()) ret.append(string_VkToolPurposeFlagBitsEXT(static_cast<VkToolPurposeFlagBitsEXT>(0)));
7903 return ret;
7904 }
7905
string_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT input_value)7906 static inline const char* string_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT input_value)
7907 {
7908 switch (input_value)
7909 {
7910 case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT:
7911 return "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT";
7912 case VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT:
7913 return "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT";
7914 case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT:
7915 return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT";
7916 case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT:
7917 return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT";
7918 case VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT:
7919 return "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT";
7920 default:
7921 return "Unhandled VkValidationFeatureEnableEXT";
7922 }
7923 }
7924
string_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT input_value)7925 static inline const char* string_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT input_value)
7926 {
7927 switch (input_value)
7928 {
7929 case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT:
7930 return "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT";
7931 case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT:
7932 return "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT";
7933 case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT:
7934 return "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT";
7935 case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT:
7936 return "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT";
7937 case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT:
7938 return "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT";
7939 case VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT:
7940 return "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT";
7941 case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT:
7942 return "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT";
7943 case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT:
7944 return "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT";
7945 default:
7946 return "Unhandled VkValidationFeatureDisableEXT";
7947 }
7948 }
7949
string_VkComponentTypeNV(VkComponentTypeNV input_value)7950 static inline const char* string_VkComponentTypeNV(VkComponentTypeNV input_value)
7951 {
7952 switch (input_value)
7953 {
7954 case VK_COMPONENT_TYPE_FLOAT16_NV:
7955 return "VK_COMPONENT_TYPE_FLOAT16_NV";
7956 case VK_COMPONENT_TYPE_FLOAT32_NV:
7957 return "VK_COMPONENT_TYPE_FLOAT32_NV";
7958 case VK_COMPONENT_TYPE_FLOAT64_NV:
7959 return "VK_COMPONENT_TYPE_FLOAT64_NV";
7960 case VK_COMPONENT_TYPE_SINT16_NV:
7961 return "VK_COMPONENT_TYPE_SINT16_NV";
7962 case VK_COMPONENT_TYPE_SINT32_NV:
7963 return "VK_COMPONENT_TYPE_SINT32_NV";
7964 case VK_COMPONENT_TYPE_SINT64_NV:
7965 return "VK_COMPONENT_TYPE_SINT64_NV";
7966 case VK_COMPONENT_TYPE_SINT8_NV:
7967 return "VK_COMPONENT_TYPE_SINT8_NV";
7968 case VK_COMPONENT_TYPE_UINT16_NV:
7969 return "VK_COMPONENT_TYPE_UINT16_NV";
7970 case VK_COMPONENT_TYPE_UINT32_NV:
7971 return "VK_COMPONENT_TYPE_UINT32_NV";
7972 case VK_COMPONENT_TYPE_UINT64_NV:
7973 return "VK_COMPONENT_TYPE_UINT64_NV";
7974 case VK_COMPONENT_TYPE_UINT8_NV:
7975 return "VK_COMPONENT_TYPE_UINT8_NV";
7976 default:
7977 return "Unhandled VkComponentTypeNV";
7978 }
7979 }
7980
string_VkScopeNV(VkScopeNV input_value)7981 static inline const char* string_VkScopeNV(VkScopeNV input_value)
7982 {
7983 switch (input_value)
7984 {
7985 case VK_SCOPE_DEVICE_NV:
7986 return "VK_SCOPE_DEVICE_NV";
7987 case VK_SCOPE_QUEUE_FAMILY_NV:
7988 return "VK_SCOPE_QUEUE_FAMILY_NV";
7989 case VK_SCOPE_SUBGROUP_NV:
7990 return "VK_SCOPE_SUBGROUP_NV";
7991 case VK_SCOPE_WORKGROUP_NV:
7992 return "VK_SCOPE_WORKGROUP_NV";
7993 default:
7994 return "Unhandled VkScopeNV";
7995 }
7996 }
7997
string_VkCoverageReductionModeNV(VkCoverageReductionModeNV input_value)7998 static inline const char* string_VkCoverageReductionModeNV(VkCoverageReductionModeNV input_value)
7999 {
8000 switch (input_value)
8001 {
8002 case VK_COVERAGE_REDUCTION_MODE_MERGE_NV:
8003 return "VK_COVERAGE_REDUCTION_MODE_MERGE_NV";
8004 case VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV:
8005 return "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV";
8006 default:
8007 return "Unhandled VkCoverageReductionModeNV";
8008 }
8009 }
8010
string_VkProvokingVertexModeEXT(VkProvokingVertexModeEXT input_value)8011 static inline const char* string_VkProvokingVertexModeEXT(VkProvokingVertexModeEXT input_value)
8012 {
8013 switch (input_value)
8014 {
8015 case VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT:
8016 return "VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT";
8017 case VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT:
8018 return "VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT";
8019 default:
8020 return "Unhandled VkProvokingVertexModeEXT";
8021 }
8022 }
8023
8024
8025 #ifdef VK_USE_PLATFORM_WIN32_KHR
8026
string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT input_value)8027 static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT input_value)
8028 {
8029 switch (input_value)
8030 {
8031 case VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT:
8032 return "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT";
8033 case VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT:
8034 return "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT";
8035 case VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT:
8036 return "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT";
8037 case VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT:
8038 return "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT";
8039 default:
8040 return "Unhandled VkFullScreenExclusiveEXT";
8041 }
8042 }
8043 #endif // VK_USE_PLATFORM_WIN32_KHR
8044
string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)8045 static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)
8046 {
8047 switch (input_value)
8048 {
8049 case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
8050 return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
8051 case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
8052 return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
8053 case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
8054 return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
8055 case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
8056 return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
8057 default:
8058 return "Unhandled VkLineRasterizationModeEXT";
8059 }
8060 }
8061
string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV input_value)8062 static inline const char* string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV input_value)
8063 {
8064 switch (input_value)
8065 {
8066 case VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV:
8067 return "VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV";
8068 default:
8069 return "Unhandled VkIndirectStateFlagBitsNV";
8070 }
8071 }
8072
string_VkIndirectStateFlagsNV(VkIndirectStateFlagsNV input_value)8073 static inline std::string string_VkIndirectStateFlagsNV(VkIndirectStateFlagsNV input_value)
8074 {
8075 std::string ret;
8076 int index = 0;
8077 while(input_value) {
8078 if (input_value & 1) {
8079 if( !ret.empty()) ret.append("|");
8080 ret.append(string_VkIndirectStateFlagBitsNV(static_cast<VkIndirectStateFlagBitsNV>(1U << index)));
8081 }
8082 ++index;
8083 input_value >>= 1;
8084 }
8085 if( ret.empty()) ret.append(string_VkIndirectStateFlagBitsNV(static_cast<VkIndirectStateFlagBitsNV>(0)));
8086 return ret;
8087 }
8088
string_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV input_value)8089 static inline const char* string_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV input_value)
8090 {
8091 switch (input_value)
8092 {
8093 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV:
8094 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV";
8095 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV:
8096 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV";
8097 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV:
8098 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV";
8099 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV:
8100 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV";
8101 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV:
8102 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV";
8103 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
8104 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV";
8105 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV:
8106 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV";
8107 case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV:
8108 return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV";
8109 default:
8110 return "Unhandled VkIndirectCommandsTokenTypeNV";
8111 }
8112 }
8113
string_VkIndirectCommandsLayoutUsageFlagBitsNV(VkIndirectCommandsLayoutUsageFlagBitsNV input_value)8114 static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsNV(VkIndirectCommandsLayoutUsageFlagBitsNV input_value)
8115 {
8116 switch (input_value)
8117 {
8118 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV:
8119 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV";
8120 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV:
8121 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV";
8122 case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV:
8123 return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV";
8124 default:
8125 return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsNV";
8126 }
8127 }
8128
string_VkIndirectCommandsLayoutUsageFlagsNV(VkIndirectCommandsLayoutUsageFlagsNV input_value)8129 static inline std::string string_VkIndirectCommandsLayoutUsageFlagsNV(VkIndirectCommandsLayoutUsageFlagsNV input_value)
8130 {
8131 std::string ret;
8132 int index = 0;
8133 while(input_value) {
8134 if (input_value & 1) {
8135 if( !ret.empty()) ret.append("|");
8136 ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(1U << index)));
8137 }
8138 ++index;
8139 input_value >>= 1;
8140 }
8141 if( ret.empty()) ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(0)));
8142 return ret;
8143 }
8144
string_VkDeviceMemoryReportEventTypeEXT(VkDeviceMemoryReportEventTypeEXT input_value)8145 static inline const char* string_VkDeviceMemoryReportEventTypeEXT(VkDeviceMemoryReportEventTypeEXT input_value)
8146 {
8147 switch (input_value)
8148 {
8149 case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT:
8150 return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT";
8151 case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT:
8152 return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT";
8153 case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT:
8154 return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT";
8155 case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT:
8156 return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT";
8157 case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT:
8158 return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT";
8159 default:
8160 return "Unhandled VkDeviceMemoryReportEventTypeEXT";
8161 }
8162 }
8163
string_VkDeviceDiagnosticsConfigFlagBitsNV(VkDeviceDiagnosticsConfigFlagBitsNV input_value)8164 static inline const char* string_VkDeviceDiagnosticsConfigFlagBitsNV(VkDeviceDiagnosticsConfigFlagBitsNV input_value)
8165 {
8166 switch (input_value)
8167 {
8168 case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV:
8169 return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV";
8170 case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV:
8171 return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV";
8172 case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV:
8173 return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV";
8174 default:
8175 return "Unhandled VkDeviceDiagnosticsConfigFlagBitsNV";
8176 }
8177 }
8178
string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagnosticsConfigFlagsNV input_value)8179 static inline std::string string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagnosticsConfigFlagsNV input_value)
8180 {
8181 std::string ret;
8182 int index = 0;
8183 while(input_value) {
8184 if (input_value & 1) {
8185 if( !ret.empty()) ret.append("|");
8186 ret.append(string_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(1U << index)));
8187 }
8188 ++index;
8189 input_value >>= 1;
8190 }
8191 if( ret.empty()) ret.append(string_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(0)));
8192 return ret;
8193 }
8194
string_VkFragmentShadingRateTypeNV(VkFragmentShadingRateTypeNV input_value)8195 static inline const char* string_VkFragmentShadingRateTypeNV(VkFragmentShadingRateTypeNV input_value)
8196 {
8197 switch (input_value)
8198 {
8199 case VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV:
8200 return "VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV";
8201 case VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV:
8202 return "VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV";
8203 default:
8204 return "Unhandled VkFragmentShadingRateTypeNV";
8205 }
8206 }
8207
string_VkFragmentShadingRateNV(VkFragmentShadingRateNV input_value)8208 static inline const char* string_VkFragmentShadingRateNV(VkFragmentShadingRateNV input_value)
8209 {
8210 switch (input_value)
8211 {
8212 case VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV:
8213 return "VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV";
8214 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV:
8215 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV";
8216 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV:
8217 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV";
8218 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV:
8219 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV";
8220 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV:
8221 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV";
8222 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV:
8223 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV";
8224 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV:
8225 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV";
8226 case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV:
8227 return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV";
8228 case VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV:
8229 return "VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV";
8230 case VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV:
8231 return "VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV";
8232 case VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV:
8233 return "VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV";
8234 case VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV:
8235 return "VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV";
8236 default:
8237 return "Unhandled VkFragmentShadingRateNV";
8238 }
8239 }
8240
string_VkAccelerationStructureMotionInstanceTypeNV(VkAccelerationStructureMotionInstanceTypeNV input_value)8241 static inline const char* string_VkAccelerationStructureMotionInstanceTypeNV(VkAccelerationStructureMotionInstanceTypeNV input_value)
8242 {
8243 switch (input_value)
8244 {
8245 case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV:
8246 return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV";
8247 case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV:
8248 return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV";
8249 case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV:
8250 return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV";
8251 default:
8252 return "Unhandled VkAccelerationStructureMotionInstanceTypeNV";
8253 }
8254 }
8255
string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value)8256 static inline const char* string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value)
8257 {
8258 switch (input_value)
8259 {
8260 case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR:
8261 return "VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR";
8262 case VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR:
8263 return "VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR";
8264 default:
8265 return "Unhandled VkBuildAccelerationStructureModeKHR";
8266 }
8267 }
8268
string_VkAccelerationStructureBuildTypeKHR(VkAccelerationStructureBuildTypeKHR input_value)8269 static inline const char* string_VkAccelerationStructureBuildTypeKHR(VkAccelerationStructureBuildTypeKHR input_value)
8270 {
8271 switch (input_value)
8272 {
8273 case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR:
8274 return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR";
8275 case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR:
8276 return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR";
8277 case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR:
8278 return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR";
8279 default:
8280 return "Unhandled VkAccelerationStructureBuildTypeKHR";
8281 }
8282 }
8283
string_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR input_value)8284 static inline const char* string_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR input_value)
8285 {
8286 switch (input_value)
8287 {
8288 case VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR:
8289 return "VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR";
8290 case VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV:
8291 return "VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV";
8292 default:
8293 return "Unhandled VkAccelerationStructureCreateFlagBitsKHR";
8294 }
8295 }
8296
string_VkAccelerationStructureCreateFlagsKHR(VkAccelerationStructureCreateFlagsKHR input_value)8297 static inline std::string string_VkAccelerationStructureCreateFlagsKHR(VkAccelerationStructureCreateFlagsKHR input_value)
8298 {
8299 std::string ret;
8300 int index = 0;
8301 while(input_value) {
8302 if (input_value & 1) {
8303 if( !ret.empty()) ret.append("|");
8304 ret.append(string_VkAccelerationStructureCreateFlagBitsKHR(static_cast<VkAccelerationStructureCreateFlagBitsKHR>(1U << index)));
8305 }
8306 ++index;
8307 input_value >>= 1;
8308 }
8309 if( ret.empty()) ret.append(string_VkAccelerationStructureCreateFlagBitsKHR(static_cast<VkAccelerationStructureCreateFlagBitsKHR>(0)));
8310 return ret;
8311 }
8312
string_VkAccelerationStructureCompatibilityKHR(VkAccelerationStructureCompatibilityKHR input_value)8313 static inline const char* string_VkAccelerationStructureCompatibilityKHR(VkAccelerationStructureCompatibilityKHR input_value)
8314 {
8315 switch (input_value)
8316 {
8317 case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR:
8318 return "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR";
8319 case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR:
8320 return "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR";
8321 default:
8322 return "Unhandled VkAccelerationStructureCompatibilityKHR";
8323 }
8324 }
8325
string_VkShaderGroupShaderKHR(VkShaderGroupShaderKHR input_value)8326 static inline const char* string_VkShaderGroupShaderKHR(VkShaderGroupShaderKHR input_value)
8327 {
8328 switch (input_value)
8329 {
8330 case VK_SHADER_GROUP_SHADER_ANY_HIT_KHR:
8331 return "VK_SHADER_GROUP_SHADER_ANY_HIT_KHR";
8332 case VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR:
8333 return "VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR";
8334 case VK_SHADER_GROUP_SHADER_GENERAL_KHR:
8335 return "VK_SHADER_GROUP_SHADER_GENERAL_KHR";
8336 case VK_SHADER_GROUP_SHADER_INTERSECTION_KHR:
8337 return "VK_SHADER_GROUP_SHADER_INTERSECTION_KHR";
8338 default:
8339 return "Unhandled VkShaderGroupShaderKHR";
8340 }
8341 }
8342
GetPhysDevFeatureString(uint32_t index)8343 static inline const char * GetPhysDevFeatureString(uint32_t index) {
8344 const char * IndexToPhysDevFeatureString[] = {
8345 "robustBufferAccess",
8346 "fullDrawIndexUint32",
8347 "imageCubeArray",
8348 "independentBlend",
8349 "geometryShader",
8350 "tessellationShader",
8351 "sampleRateShading",
8352 "dualSrcBlend",
8353 "logicOp",
8354 "multiDrawIndirect",
8355 "drawIndirectFirstInstance",
8356 "depthClamp",
8357 "depthBiasClamp",
8358 "fillModeNonSolid",
8359 "depthBounds",
8360 "wideLines",
8361 "largePoints",
8362 "alphaToOne",
8363 "multiViewport",
8364 "samplerAnisotropy",
8365 "textureCompressionETC2",
8366 "textureCompressionASTC_LDR",
8367 "textureCompressionBC",
8368 "occlusionQueryPrecise",
8369 "pipelineStatisticsQuery",
8370 "vertexPipelineStoresAndAtomics",
8371 "fragmentStoresAndAtomics",
8372 "shaderTessellationAndGeometryPointSize",
8373 "shaderImageGatherExtended",
8374 "shaderStorageImageExtendedFormats",
8375 "shaderStorageImageMultisample",
8376 "shaderStorageImageReadWithoutFormat",
8377 "shaderStorageImageWriteWithoutFormat",
8378 "shaderUniformBufferArrayDynamicIndexing",
8379 "shaderSampledImageArrayDynamicIndexing",
8380 "shaderStorageBufferArrayDynamicIndexing",
8381 "shaderStorageImageArrayDynamicIndexing",
8382 "shaderClipDistance",
8383 "shaderCullDistance",
8384 "shaderFloat64",
8385 "shaderInt64",
8386 "shaderInt16",
8387 "shaderResourceResidency",
8388 "shaderResourceMinLod",
8389 "sparseBinding",
8390 "sparseResidencyBuffer",
8391 "sparseResidencyImage2D",
8392 "sparseResidencyImage3D",
8393 "sparseResidency2Samples",
8394 "sparseResidency4Samples",
8395 "sparseResidency8Samples",
8396 "sparseResidency16Samples",
8397 "sparseResidencyAliased",
8398 "variableMultisampleRate",
8399 "inheritedQueries",
8400 };
8401
8402 return IndexToPhysDevFeatureString[index];
8403 }
8404
IsDuplicatePnext(VkStructureType input_value)8405 static inline bool IsDuplicatePnext(VkStructureType input_value)
8406 {
8407 switch (input_value)
8408 {
8409 case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
8410 case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
8411 case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
8412 return true;
8413 default:
8414 return false;
8415 }
8416 }
8417