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