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