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