Blender V5.3
vk_to_string.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <sstream>
10
11#include "vk_to_string.hh"
12
13namespace blender::gpu {
14
16static std::string to_string_handle(uint64_t vk_handle)
17{
18 std::stringstream ss;
19 ss << std::hex << std::showbase << vk_handle;
20 return ss.str();
21}
22
23const char *to_string(VkResult result)
24{
25#define FORMAT_ERROR(X) \
26 case X: { \
27 return "" #X; \
28 }
29
30 switch (result) {
31 FORMAT_ERROR(VK_NOT_READY);
32 FORMAT_ERROR(VK_TIMEOUT);
33 FORMAT_ERROR(VK_EVENT_SET);
34 FORMAT_ERROR(VK_EVENT_RESET);
35 FORMAT_ERROR(VK_INCOMPLETE);
36 FORMAT_ERROR(VK_ERROR_OUT_OF_HOST_MEMORY);
37 FORMAT_ERROR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
38 FORMAT_ERROR(VK_ERROR_INITIALIZATION_FAILED);
39 FORMAT_ERROR(VK_ERROR_DEVICE_LOST);
40 FORMAT_ERROR(VK_ERROR_MEMORY_MAP_FAILED);
41 FORMAT_ERROR(VK_ERROR_LAYER_NOT_PRESENT);
42 FORMAT_ERROR(VK_ERROR_EXTENSION_NOT_PRESENT);
43 FORMAT_ERROR(VK_ERROR_FEATURE_NOT_PRESENT);
44 FORMAT_ERROR(VK_ERROR_INCOMPATIBLE_DRIVER);
45 FORMAT_ERROR(VK_ERROR_TOO_MANY_OBJECTS);
46 FORMAT_ERROR(VK_ERROR_FORMAT_NOT_SUPPORTED);
47 FORMAT_ERROR(VK_ERROR_FRAGMENTED_POOL);
48 FORMAT_ERROR(VK_ERROR_UNKNOWN);
49 FORMAT_ERROR(VK_ERROR_OUT_OF_POOL_MEMORY);
50 FORMAT_ERROR(VK_ERROR_INVALID_EXTERNAL_HANDLE);
51 FORMAT_ERROR(VK_ERROR_FRAGMENTATION);
52 FORMAT_ERROR(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
53 FORMAT_ERROR(VK_ERROR_SURFACE_LOST_KHR);
54 FORMAT_ERROR(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
55 FORMAT_ERROR(VK_SUBOPTIMAL_KHR);
56 FORMAT_ERROR(VK_ERROR_OUT_OF_DATE_KHR);
57 FORMAT_ERROR(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
58 FORMAT_ERROR(VK_ERROR_VALIDATION_FAILED_EXT);
59 FORMAT_ERROR(VK_ERROR_INVALID_SHADER_NV);
60 FORMAT_ERROR(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
61 FORMAT_ERROR(VK_ERROR_NOT_PERMITTED_EXT);
62 FORMAT_ERROR(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
63 FORMAT_ERROR(VK_THREAD_IDLE_KHR);
64 FORMAT_ERROR(VK_THREAD_DONE_KHR);
65 FORMAT_ERROR(VK_OPERATION_DEFERRED_KHR);
66 FORMAT_ERROR(VK_OPERATION_NOT_DEFERRED_KHR);
67 FORMAT_ERROR(VK_PIPELINE_COMPILE_REQUIRED_EXT);
68 default:
69 return "Unknown Error";
70 }
71}
72
73std::string to_string(VkBuffer vk_handle)
74{
75 return to_string_handle(uint64_t(vk_handle));
76}
77
78#if VK_USE_64_BIT_PTR_DEFINES == 1
79std::string to_string(VkImage vk_handle)
80{
81 return to_string_handle(uint64_t(vk_handle));
82}
83
84std::string to_string(VkImageView vk_handle)
85{
86 return to_string_handle(uint64_t(vk_handle));
87}
88
89std::string to_string(VkRenderPass vk_handle)
90{
91 return to_string_handle(uint64_t(vk_handle));
92}
93
94std::string to_string(VkFramebuffer vk_handle)
95{
96 return to_string_handle(uint64_t(vk_handle));
97}
98
99std::string to_string(VkPipelineLayout vk_handle)
100{
101 return to_string_handle(uint64_t(vk_handle));
102}
103
104std::string to_string(VkPipeline vk_handle)
105{
106 return to_string_handle(uint64_t(vk_handle));
107}
108
109std::string to_string(VkDescriptorSet vk_handle)
110{
111 return to_string_handle(uint64_t(vk_handle));
112}
113#endif
114
115const char *to_string(const VkAttachmentLoadOp vk_attachment_load_op)
116{
117 switch (vk_attachment_load_op) {
118 case VK_ATTACHMENT_LOAD_OP_LOAD:
119 return STRINGIFY(VK_ATTACHMENT_LOAD_OP_LOAD);
120
121 case VK_ATTACHMENT_LOAD_OP_CLEAR:
122 return STRINGIFY(VK_ATTACHMENT_LOAD_OP_CLEAR);
123
124 case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
125 return STRINGIFY(VK_ATTACHMENT_LOAD_OP_DONT_CARE);
126
127 default:
128 break;
129 }
130 return STRINGIFY_ARG(vk_attachment_load_op);
131}
132
133const char *to_string(const VkAttachmentStoreOp vk_attachment_store_op)
134{
135 switch (vk_attachment_store_op) {
136 case VK_ATTACHMENT_STORE_OP_STORE:
137 return STRINGIFY(VK_ATTACHMENT_STORE_OP_STORE);
138
139 case VK_ATTACHMENT_STORE_OP_DONT_CARE:
140 return STRINGIFY(VK_ATTACHMENT_STORE_OP_DONT_CARE);
141
142 /* Extensions for VK_KHR_dynamic_rendering. */
143 case VK_ATTACHMENT_STORE_OP_NONE_KHR:
144 return STRINGIFY(VK_ATTACHMENT_STORE_OP_NONE_KHR);
145
146 default:
147 break;
148 }
149 return STRINGIFY_ARG(vk_attachment_store_op);
150}
151
152const char *to_string(const VkFilter vk_filter)
153{
154 switch (vk_filter) {
155 case VK_FILTER_NEAREST:
156 return STRINGIFY(VK_FILTER_NEAREST);
157
158 case VK_FILTER_LINEAR:
159 return STRINGIFY(VK_FILTER_LINEAR);
160
161 default:
162 break;
163 }
164 return STRINGIFY_ARG(vk_filter);
165}
166
167const char *to_string(const VkImageLayout vk_image_layout)
168{
169 switch (vk_image_layout) {
170 case VK_IMAGE_LAYOUT_UNDEFINED:
171 return STRINGIFY(VK_IMAGE_LAYOUT_UNDEFINED);
172
173 case VK_IMAGE_LAYOUT_GENERAL:
174 return STRINGIFY(VK_IMAGE_LAYOUT_GENERAL);
175
176 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
177 return STRINGIFY(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
178
179 case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR:
180 return STRINGIFY(VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR);
181
182 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
183 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
184
185 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
186 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL);
187
188 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
189 return STRINGIFY(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
190
191 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
192 return STRINGIFY(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
193
194 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
195 return STRINGIFY(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
196
197 case VK_IMAGE_LAYOUT_PREINITIALIZED:
198 return STRINGIFY(VK_IMAGE_LAYOUT_PREINITIALIZED);
199
200 /* Extensions for VK_VERSION_1_1. */
201 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
202 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL);
203
204 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
205 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL);
206
207 /* Extensions for VK_VERSION_1_2. */
208 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
209 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);
210
211 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
212 return STRINGIFY(VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL);
213
214 case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
215 return STRINGIFY(VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL);
216
217 case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
218 return STRINGIFY(VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL);
219
220 /* Extensions for VK_KHR_swapchain. */
221 case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
222 return STRINGIFY(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
223
224 default:
225 break;
226 }
227 return STRINGIFY_ARG(vk_image_layout);
228}
229
230const char *to_string(const VkIndexType vk_index_type)
231{
232 switch (vk_index_type) {
233 case VK_INDEX_TYPE_UINT16:
234 return STRINGIFY(VK_INDEX_TYPE_UINT16);
235
236 case VK_INDEX_TYPE_UINT32:
237 return STRINGIFY(VK_INDEX_TYPE_UINT32);
238
239 default:
240 break;
241 }
242 return STRINGIFY_ARG(vk_index_type);
243}
244
245const char *to_string(const VkObjectType vk_object_type)
246{
247 switch (vk_object_type) {
248 case VK_OBJECT_TYPE_UNKNOWN:
249 return STRINGIFY(VK_OBJECT_TYPE_UNKNOWN);
250
251 case VK_OBJECT_TYPE_INSTANCE:
252 return STRINGIFY(VK_OBJECT_TYPE_INSTANCE);
253
254 case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
255 return STRINGIFY(VK_OBJECT_TYPE_PHYSICAL_DEVICE);
256
257 case VK_OBJECT_TYPE_DEVICE:
258 return STRINGIFY(VK_OBJECT_TYPE_DEVICE);
259
260 case VK_OBJECT_TYPE_QUEUE:
261 return STRINGIFY(VK_OBJECT_TYPE_QUEUE);
262
263 case VK_OBJECT_TYPE_SEMAPHORE:
264 return STRINGIFY(VK_OBJECT_TYPE_SEMAPHORE);
265
266 case VK_OBJECT_TYPE_COMMAND_BUFFER:
267 return STRINGIFY(VK_OBJECT_TYPE_COMMAND_BUFFER);
268
269 case VK_OBJECT_TYPE_FENCE:
270 return STRINGIFY(VK_OBJECT_TYPE_FENCE);
271
272 case VK_OBJECT_TYPE_DEVICE_MEMORY:
273 return STRINGIFY(VK_OBJECT_TYPE_DEVICE_MEMORY);
274
275 case VK_OBJECT_TYPE_BUFFER:
276 return STRINGIFY(VK_OBJECT_TYPE_BUFFER);
277
278 case VK_OBJECT_TYPE_IMAGE:
279 return STRINGIFY(VK_OBJECT_TYPE_IMAGE);
280
281 case VK_OBJECT_TYPE_EVENT:
282 return STRINGIFY(VK_OBJECT_TYPE_EVENT);
283
284 case VK_OBJECT_TYPE_QUERY_POOL:
285 return STRINGIFY(VK_OBJECT_TYPE_QUERY_POOL);
286
287 case VK_OBJECT_TYPE_BUFFER_VIEW:
288 return STRINGIFY(VK_OBJECT_TYPE_BUFFER_VIEW);
289
290 case VK_OBJECT_TYPE_IMAGE_VIEW:
291 return STRINGIFY(VK_OBJECT_TYPE_IMAGE_VIEW);
292
293 case VK_OBJECT_TYPE_SHADER_MODULE:
294 return STRINGIFY(VK_OBJECT_TYPE_SHADER_MODULE);
295
296 case VK_OBJECT_TYPE_PIPELINE_CACHE:
297 return STRINGIFY(VK_OBJECT_TYPE_PIPELINE_CACHE);
298
299 case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
300 return STRINGIFY(VK_OBJECT_TYPE_PIPELINE_LAYOUT);
301
302 case VK_OBJECT_TYPE_RENDER_PASS:
303 return STRINGIFY(VK_OBJECT_TYPE_RENDER_PASS);
304
305 case VK_OBJECT_TYPE_PIPELINE:
306 return STRINGIFY(VK_OBJECT_TYPE_PIPELINE);
307
308 case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
309 return STRINGIFY(VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
310
311 case VK_OBJECT_TYPE_SAMPLER:
312 return STRINGIFY(VK_OBJECT_TYPE_SAMPLER);
313
314 case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
315 return STRINGIFY(VK_OBJECT_TYPE_DESCRIPTOR_POOL);
316
317 case VK_OBJECT_TYPE_DESCRIPTOR_SET:
318 return STRINGIFY(VK_OBJECT_TYPE_DESCRIPTOR_SET);
319
320 case VK_OBJECT_TYPE_FRAMEBUFFER:
321 return STRINGIFY(VK_OBJECT_TYPE_FRAMEBUFFER);
322
323 case VK_OBJECT_TYPE_COMMAND_POOL:
324 return STRINGIFY(VK_OBJECT_TYPE_COMMAND_POOL);
325
326 /* Extensions for VK_VERSION_1_1. */
327 case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
328 return STRINGIFY(VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
329
330 case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
331 return STRINGIFY(VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
332
333 /* Extensions for VK_KHR_swapchain. */
334 case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
335 return STRINGIFY(VK_OBJECT_TYPE_SWAPCHAIN_KHR);
336
337 default:
338 break;
339 }
340 return STRINGIFY_ARG(vk_object_type);
341}
342
343const char *to_string(const VkPipelineBindPoint vk_pipeline_bind_point)
344{
345 switch (vk_pipeline_bind_point) {
346 case VK_PIPELINE_BIND_POINT_GRAPHICS:
347 return STRINGIFY(VK_PIPELINE_BIND_POINT_GRAPHICS);
348
349 case VK_PIPELINE_BIND_POINT_COMPUTE:
350 return STRINGIFY(VK_PIPELINE_BIND_POINT_COMPUTE);
351
352 default:
353 break;
354 }
355 return STRINGIFY_ARG(vk_pipeline_bind_point);
356}
357
358const char *to_string(const VkResolveModeFlagBits vk_resolve_mode_flag_bits)
359{
360 switch (vk_resolve_mode_flag_bits) {
361 case VK_RESOLVE_MODE_NONE:
362 return STRINGIFY(VK_RESOLVE_MODE_NONE);
363
364 case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT:
365 return STRINGIFY(VK_RESOLVE_MODE_SAMPLE_ZERO_BIT);
366
367 case VK_RESOLVE_MODE_AVERAGE_BIT:
368 return STRINGIFY(VK_RESOLVE_MODE_AVERAGE_BIT);
369
370 case VK_RESOLVE_MODE_MIN_BIT:
371 return STRINGIFY(VK_RESOLVE_MODE_MIN_BIT);
372
373 case VK_RESOLVE_MODE_MAX_BIT:
374 return STRINGIFY(VK_RESOLVE_MODE_MAX_BIT);
375
376 default:
377 break;
378 }
379 return STRINGIFY_ARG(vk_resolve_mode_flag_bits);
380}
381
382const char *to_string(const VkSubpassContents vk_subpass_contents)
383{
384 switch (vk_subpass_contents) {
385 case VK_SUBPASS_CONTENTS_INLINE:
386 return STRINGIFY(VK_SUBPASS_CONTENTS_INLINE);
387
388 case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
389 return STRINGIFY(VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
390
391 default:
392 break;
393 }
394 return STRINGIFY_ARG(vk_subpass_contents);
395}
396
397std::string to_string_vk_access_flags(const VkAccessFlags vk_access_flags)
398{
399 std::stringstream ss;
400
401 if (vk_access_flags & VK_ACCESS_INDIRECT_COMMAND_READ_BIT) {
402 ss << STRINGIFY(VK_ACCESS_INDIRECT_COMMAND_READ_BIT) << ", ";
403 }
404 if (vk_access_flags & VK_ACCESS_INDEX_READ_BIT) {
405 ss << STRINGIFY(VK_ACCESS_INDEX_READ_BIT) << ", ";
406 }
407 if (vk_access_flags & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) {
408 ss << STRINGIFY(VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) << ", ";
409 }
410 if (vk_access_flags & VK_ACCESS_UNIFORM_READ_BIT) {
411 ss << STRINGIFY(VK_ACCESS_UNIFORM_READ_BIT) << ", ";
412 }
413 if (vk_access_flags & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) {
414 ss << STRINGIFY(VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) << ", ";
415 }
416 if (vk_access_flags & VK_ACCESS_SHADER_READ_BIT) {
417 ss << STRINGIFY(VK_ACCESS_SHADER_READ_BIT) << ", ";
418 }
419 if (vk_access_flags & VK_ACCESS_SHADER_WRITE_BIT) {
420 ss << STRINGIFY(VK_ACCESS_SHADER_WRITE_BIT) << ", ";
421 }
422 if (vk_access_flags & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) {
423 ss << STRINGIFY(VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) << ", ";
424 }
425 if (vk_access_flags & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) {
426 ss << STRINGIFY(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) << ", ";
427 }
428 if (vk_access_flags & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) {
429 ss << STRINGIFY(VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) << ", ";
430 }
431 if (vk_access_flags & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) {
432 ss << STRINGIFY(VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) << ", ";
433 }
434 if (vk_access_flags & VK_ACCESS_TRANSFER_READ_BIT) {
435 ss << STRINGIFY(VK_ACCESS_TRANSFER_READ_BIT) << ", ";
436 }
437 if (vk_access_flags & VK_ACCESS_TRANSFER_WRITE_BIT) {
438 ss << STRINGIFY(VK_ACCESS_TRANSFER_WRITE_BIT) << ", ";
439 }
440 if (vk_access_flags & VK_ACCESS_HOST_READ_BIT) {
441 ss << STRINGIFY(VK_ACCESS_HOST_READ_BIT) << ", ";
442 }
443 if (vk_access_flags & VK_ACCESS_HOST_WRITE_BIT) {
444 ss << STRINGIFY(VK_ACCESS_HOST_WRITE_BIT) << ", ";
445 }
446 if (vk_access_flags & VK_ACCESS_MEMORY_READ_BIT) {
447 ss << STRINGIFY(VK_ACCESS_MEMORY_READ_BIT) << ", ";
448 }
449 if (vk_access_flags & VK_ACCESS_MEMORY_WRITE_BIT) {
450 ss << STRINGIFY(VK_ACCESS_MEMORY_WRITE_BIT) << ", ";
451 }
452
453 std::string result = ss.str();
454 if (result.size() >= 2) {
455 result.erase(result.size() - 2, 2);
456 }
457 return result;
458}
459
460std::string to_string_vk_dependency_flags(const VkDependencyFlags vk_dependency_flags)
461{
462 std::stringstream ss;
463
464 if (vk_dependency_flags & VK_DEPENDENCY_BY_REGION_BIT) {
465 ss << STRINGIFY(VK_DEPENDENCY_BY_REGION_BIT) << ", ";
466 }
467 /* Extensions for VK_VERSION_1_1. */
468 if (vk_dependency_flags & VK_DEPENDENCY_DEVICE_GROUP_BIT) {
469 ss << STRINGIFY(VK_DEPENDENCY_DEVICE_GROUP_BIT) << ", ";
470 }
471 if (vk_dependency_flags & VK_DEPENDENCY_VIEW_LOCAL_BIT) {
472 ss << STRINGIFY(VK_DEPENDENCY_VIEW_LOCAL_BIT) << ", ";
473 }
474
475 std::string result = ss.str();
476 if (result.size() >= 2) {
477 result.erase(result.size() - 2, 2);
478 }
479 return result;
480}
481
482std::string to_string_vk_image_aspect_flags(const VkImageAspectFlags vk_image_aspect_flags)
483{
484 std::stringstream ss;
485
486 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_COLOR_BIT) {
487 ss << STRINGIFY(VK_IMAGE_ASPECT_COLOR_BIT) << ", ";
488 }
489 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_DEPTH_BIT) {
490 ss << STRINGIFY(VK_IMAGE_ASPECT_DEPTH_BIT) << ", ";
491 }
492 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_STENCIL_BIT) {
493 ss << STRINGIFY(VK_IMAGE_ASPECT_STENCIL_BIT) << ", ";
494 }
495 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_METADATA_BIT) {
496 ss << STRINGIFY(VK_IMAGE_ASPECT_METADATA_BIT) << ", ";
497 }
498 /* Extensions for VK_VERSION_1_1. */
499 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_PLANE_0_BIT) {
500 ss << STRINGIFY(VK_IMAGE_ASPECT_PLANE_0_BIT) << ", ";
501 }
502 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_PLANE_1_BIT) {
503 ss << STRINGIFY(VK_IMAGE_ASPECT_PLANE_1_BIT) << ", ";
504 }
505 if (vk_image_aspect_flags & VK_IMAGE_ASPECT_PLANE_2_BIT) {
506 ss << STRINGIFY(VK_IMAGE_ASPECT_PLANE_2_BIT) << ", ";
507 }
508
509 std::string result = ss.str();
510 if (result.size() >= 2) {
511 result.erase(result.size() - 2, 2);
512 }
513 return result;
514}
515
516std::string to_string_vk_pipeline_stage_flags(const VkPipelineStageFlags vk_pipeline_stage_flags)
517{
518 std::stringstream ss;
519
520 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) {
521 ss << STRINGIFY(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) << ", ";
522 }
523 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) {
524 ss << STRINGIFY(VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) << ", ";
525 }
526 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) {
527 ss << STRINGIFY(VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) << ", ";
528 }
529 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) {
530 ss << STRINGIFY(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) << ", ";
531 }
532 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) {
533 ss << STRINGIFY(VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) << ", ";
534 }
535 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) {
536 ss << STRINGIFY(VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) << ", ";
537 }
538 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) {
539 ss << STRINGIFY(VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) << ", ";
540 }
541 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) {
542 ss << STRINGIFY(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) << ", ";
543 }
544 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) {
545 ss << STRINGIFY(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) << ", ";
546 }
547 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) {
548 ss << STRINGIFY(VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) << ", ";
549 }
550 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) {
551 ss << STRINGIFY(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) << ", ";
552 }
553 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) {
554 ss << STRINGIFY(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) << ", ";
555 }
556 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_TRANSFER_BIT) {
557 ss << STRINGIFY(VK_PIPELINE_STAGE_TRANSFER_BIT) << ", ";
558 }
559 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT) {
560 ss << STRINGIFY(VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT) << ", ";
561 }
562 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_HOST_BIT) {
563 ss << STRINGIFY(VK_PIPELINE_STAGE_HOST_BIT) << ", ";
564 }
565 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) {
566 ss << STRINGIFY(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) << ", ";
567 }
568 if (vk_pipeline_stage_flags & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) {
569 ss << STRINGIFY(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) << ", ";
570 }
571
572 std::string result = ss.str();
573 if (result.size() >= 2) {
574 result.erase(result.size() - 2, 2);
575 }
576 return result;
577}
578
579std::string to_string_vk_rendering_flags(const VkRenderingFlags vk_rendering_flags)
580{
581 std::stringstream ss;
582
583 if (vk_rendering_flags & VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT) {
584 ss << STRINGIFY(VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT) << ", ";
585 }
586 if (vk_rendering_flags & VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR) {
587 ss << STRINGIFY(VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR) << ", ";
588 }
589 if (vk_rendering_flags & VK_RENDERING_SUSPENDING_BIT) {
590 ss << STRINGIFY(VK_RENDERING_SUSPENDING_BIT) << ", ";
591 }
592 if (vk_rendering_flags & VK_RENDERING_SUSPENDING_BIT_KHR) {
593 ss << STRINGIFY(VK_RENDERING_SUSPENDING_BIT_KHR) << ", ";
594 }
595 if (vk_rendering_flags & VK_RENDERING_RESUMING_BIT) {
596 ss << STRINGIFY(VK_RENDERING_RESUMING_BIT) << ", ";
597 }
598 if (vk_rendering_flags & VK_RENDERING_RESUMING_BIT_KHR) {
599 ss << STRINGIFY(VK_RENDERING_RESUMING_BIT_KHR) << ", ";
600 }
601
602 std::string result = ss.str();
603 if (result.size() >= 2) {
604 result.erase(result.size() - 2, 2);
605 }
606 return result;
607}
608
609std::string to_string_vk_shader_stage_flags(const VkShaderStageFlags vk_shader_stage_flags)
610{
611 std::stringstream ss;
612
613 if (vk_shader_stage_flags & VK_SHADER_STAGE_VERTEX_BIT) {
614 ss << STRINGIFY(VK_SHADER_STAGE_VERTEX_BIT) << ", ";
615 }
616 if (vk_shader_stage_flags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) {
617 ss << STRINGIFY(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) << ", ";
618 }
619 if (vk_shader_stage_flags & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
620 ss << STRINGIFY(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) << ", ";
621 }
622 if (vk_shader_stage_flags & VK_SHADER_STAGE_GEOMETRY_BIT) {
623 ss << STRINGIFY(VK_SHADER_STAGE_GEOMETRY_BIT) << ", ";
624 }
625 if (vk_shader_stage_flags & VK_SHADER_STAGE_FRAGMENT_BIT) {
626 ss << STRINGIFY(VK_SHADER_STAGE_FRAGMENT_BIT) << ", ";
627 }
628 if (vk_shader_stage_flags & VK_SHADER_STAGE_COMPUTE_BIT) {
629 ss << STRINGIFY(VK_SHADER_STAGE_COMPUTE_BIT) << ", ";
630 }
631 if (vk_shader_stage_flags & VK_SHADER_STAGE_ALL_GRAPHICS) {
632 ss << STRINGIFY(VK_SHADER_STAGE_ALL_GRAPHICS) << ", ";
633 }
634 if (vk_shader_stage_flags & VK_SHADER_STAGE_ALL) {
635 ss << STRINGIFY(VK_SHADER_STAGE_ALL) << ", ";
636 }
637
638 std::string result = ss.str();
639 if (result.size() >= 2) {
640 result.erase(result.size() - 2, 2);
641 }
642 return result;
643}
644
645std::string to_string(const VkBufferCopy &vk_buffer_copy, int indentation_level)
646{
647 UNUSED_VARS(indentation_level);
648 std::stringstream ss;
649 ss << "src_offset=" << vk_buffer_copy.srcOffset;
650 ss << ", dst_offset=" << vk_buffer_copy.dstOffset;
651 ss << ", size=" << vk_buffer_copy.size;
652
653 return ss.str();
654}
655
656std::string to_string(const VkBufferImageCopy &vk_buffer_image_copy, int indentation_level)
657{
658 std::stringstream ss;
659 ss << "buffer_offset=" << vk_buffer_image_copy.bufferOffset;
660 ss << ", buffer_row_length=" << vk_buffer_image_copy.bufferRowLength;
661 ss << ", buffer_image_height=" << vk_buffer_image_copy.bufferImageHeight;
662 ss << ", image_subresource=" << std::endl;
663 ss << std::string(indentation_level * 2 + 2, ' ')
664 << to_string(vk_buffer_image_copy.imageSubresource, indentation_level + 1);
665 ss << std::string(indentation_level * 2, ' ');
666 ss << ", image_offset=" << std::endl;
667 ss << std::string(indentation_level * 2 + 2, ' ')
668 << to_string(vk_buffer_image_copy.imageOffset, indentation_level + 1);
669 ss << std::string(indentation_level * 2, ' ');
670 ss << ", image_extent=" << std::endl;
671 ss << std::string(indentation_level * 2 + 2, ' ')
672 << to_string(vk_buffer_image_copy.imageExtent, indentation_level + 1);
673 ss << std::string(indentation_level * 2, ' ');
674
675 return ss.str();
676}
677
678std::string to_string(const VkBufferMemoryBarrier &vk_buffer_memory_barrier, int indentation_level)
679{
680 UNUSED_VARS(indentation_level);
681 std::stringstream ss;
682 ss << "src_access_mask=" << to_string_vk_access_flags(vk_buffer_memory_barrier.srcAccessMask);
683 ss << ", dst_access_mask=" << to_string_vk_access_flags(vk_buffer_memory_barrier.dstAccessMask);
684 ss << ", buffer=" << to_string(vk_buffer_memory_barrier.buffer);
685 ss << ", offset=" << vk_buffer_memory_barrier.offset;
686 ss << ", size=" << vk_buffer_memory_barrier.size;
687
688 return ss.str();
689}
690
691std::string to_string(const VkClearAttachment &vk_clear_attachment, int indentation_level)
692{
693 UNUSED_VARS(indentation_level);
694 std::stringstream ss;
695 ss << "aspect_mask=" << to_string_vk_image_aspect_flags(vk_clear_attachment.aspectMask);
696 ss << ", color_attachment=" << vk_clear_attachment.colorAttachment;
697
698 return ss.str();
699}
700
701std::string to_string(const VkClearDepthStencilValue &vk_clear_depth_stencil_value,
702 int indentation_level)
703{
704 UNUSED_VARS(indentation_level);
705 std::stringstream ss;
706 ss << "depth=" << vk_clear_depth_stencil_value.depth;
707 ss << ", stencil=" << vk_clear_depth_stencil_value.stencil;
708
709 return ss.str();
710}
711
712std::string to_string(const VkClearRect &vk_clear_rect, int indentation_level)
713{
714 std::stringstream ss;
715 ss << "rect=" << std::endl;
716 ss << std::string(indentation_level * 2 + 2, ' ')
717 << to_string(vk_clear_rect.rect, indentation_level + 1);
718 ss << std::string(indentation_level * 2, ' ');
719 ss << ", base_array_layer=" << vk_clear_rect.baseArrayLayer;
720 ss << ", layer_count=" << vk_clear_rect.layerCount;
721
722 return ss.str();
723}
724
725std::string to_string(const VkExtent2D &vk_extent2_d, int indentation_level)
726{
727 UNUSED_VARS(indentation_level);
728 std::stringstream ss;
729 ss << "width=" << vk_extent2_d.width;
730 ss << ", height=" << vk_extent2_d.height;
731
732 return ss.str();
733}
734
735std::string to_string(const VkExtent3D &vk_extent3_d, int indentation_level)
736{
737 UNUSED_VARS(indentation_level);
738 std::stringstream ss;
739 ss << "width=" << vk_extent3_d.width;
740 ss << ", height=" << vk_extent3_d.height;
741 ss << ", depth=" << vk_extent3_d.depth;
742
743 return ss.str();
744}
745
746std::string to_string(const VkImageBlit &vk_image_blit, int indentation_level)
747{
748 std::stringstream ss;
749 ss << "src_subresource=" << std::endl;
750 ss << std::string(indentation_level * 2 + 2, ' ')
751 << to_string(vk_image_blit.srcSubresource, indentation_level + 1);
752 ss << std::string(indentation_level * 2, ' ');
753 ss << ", dst_subresource=" << std::endl;
754 ss << std::string(indentation_level * 2 + 2, ' ')
755 << to_string(vk_image_blit.dstSubresource, indentation_level + 1);
756 ss << std::string(indentation_level * 2, ' ');
757
758 return ss.str();
759}
760
761std::string to_string(const VkImageCopy &vk_image_copy, int indentation_level)
762{
763 std::stringstream ss;
764 ss << "src_subresource=" << std::endl;
765 ss << std::string(indentation_level * 2 + 2, ' ')
766 << to_string(vk_image_copy.srcSubresource, indentation_level + 1);
767 ss << std::string(indentation_level * 2, ' ');
768 ss << ", src_offset=" << std::endl;
769 ss << std::string(indentation_level * 2 + 2, ' ')
770 << to_string(vk_image_copy.srcOffset, indentation_level + 1);
771 ss << std::string(indentation_level * 2, ' ');
772 ss << ", dst_subresource=" << std::endl;
773 ss << std::string(indentation_level * 2 + 2, ' ')
774 << to_string(vk_image_copy.dstSubresource, indentation_level + 1);
775 ss << std::string(indentation_level * 2, ' ');
776 ss << ", dst_offset=" << std::endl;
777 ss << std::string(indentation_level * 2 + 2, ' ')
778 << to_string(vk_image_copy.dstOffset, indentation_level + 1);
779 ss << std::string(indentation_level * 2, ' ');
780 ss << ", extent=" << std::endl;
781 ss << std::string(indentation_level * 2 + 2, ' ')
782 << to_string(vk_image_copy.extent, indentation_level + 1);
783 ss << std::string(indentation_level * 2, ' ');
784
785 return ss.str();
786}
787
788std::string to_string(const VkImageMemoryBarrier &vk_image_memory_barrier, int indentation_level)
789{
790 std::stringstream ss;
791 ss << "src_access_mask=" << to_string_vk_access_flags(vk_image_memory_barrier.srcAccessMask);
792 ss << ", dst_access_mask=" << to_string_vk_access_flags(vk_image_memory_barrier.dstAccessMask);
793 ss << ", old_layout=" << to_string(vk_image_memory_barrier.oldLayout);
794 ss << ", new_layout=" << to_string(vk_image_memory_barrier.newLayout);
795 ss << ", image=" << to_string(vk_image_memory_barrier.image);
796 ss << ", subresource_range=" << std::endl;
797 ss << std::string(indentation_level * 2 + 2, ' ')
798 << to_string(vk_image_memory_barrier.subresourceRange, indentation_level + 1);
799 ss << std::string(indentation_level * 2, ' ');
800
801 return ss.str();
802}
803
804std::string to_string(const VkImageSubresourceLayers &vk_image_subresource_layers,
805 int indentation_level)
806{
807 UNUSED_VARS(indentation_level);
808 std::stringstream ss;
809 ss << "aspect_mask=" << to_string_vk_image_aspect_flags(vk_image_subresource_layers.aspectMask);
810 ss << ", mip_level=" << vk_image_subresource_layers.mipLevel;
811 ss << ", base_array_layer=" << vk_image_subresource_layers.baseArrayLayer;
812 ss << ", layer_count=" << vk_image_subresource_layers.layerCount;
813
814 return ss.str();
815}
816
817std::string to_string(const VkImageSubresourceRange &vk_image_subresource_range,
818 int indentation_level)
819{
820 UNUSED_VARS(indentation_level);
821 std::stringstream ss;
822 ss << "aspect_mask=" << to_string_vk_image_aspect_flags(vk_image_subresource_range.aspectMask);
823 ss << ", base_mip_level=" << vk_image_subresource_range.baseMipLevel;
824 ss << ", level_count=" << vk_image_subresource_range.levelCount;
825 ss << ", base_array_layer=" << vk_image_subresource_range.baseArrayLayer;
826 ss << ", layer_count=" << vk_image_subresource_range.layerCount;
827
828 return ss.str();
829}
830
831std::string to_string(const VkMemoryBarrier &vk_memory_barrier, int indentation_level)
832{
833 UNUSED_VARS(indentation_level);
834 std::stringstream ss;
835 ss << "src_access_mask=" << to_string_vk_access_flags(vk_memory_barrier.srcAccessMask);
836 ss << ", dst_access_mask=" << to_string_vk_access_flags(vk_memory_barrier.dstAccessMask);
837
838 return ss.str();
839}
840
841std::string to_string(const VkOffset2D &vk_offset2_d, int indentation_level)
842{
843 UNUSED_VARS(indentation_level);
844 std::stringstream ss;
845 ss << "x=" << vk_offset2_d.x;
846 ss << ", y=" << vk_offset2_d.y;
847
848 return ss.str();
849}
850
851std::string to_string(const VkOffset3D &vk_offset3_d, int indentation_level)
852{
853 UNUSED_VARS(indentation_level);
854 std::stringstream ss;
855 ss << "x=" << vk_offset3_d.x;
856 ss << ", y=" << vk_offset3_d.y;
857 ss << ", z=" << vk_offset3_d.z;
858
859 return ss.str();
860}
861
862std::string to_string(const VkRect2D &vk_rect2_d, int indentation_level)
863{
864 std::stringstream ss;
865 ss << "offset=" << std::endl;
866 ss << std::string(indentation_level * 2 + 2, ' ')
867 << to_string(vk_rect2_d.offset, indentation_level + 1);
868 ss << std::string(indentation_level * 2, ' ');
869 ss << ", extent=" << std::endl;
870 ss << std::string(indentation_level * 2 + 2, ' ')
871 << to_string(vk_rect2_d.extent, indentation_level + 1);
872 ss << std::string(indentation_level * 2, ' ');
873
874 return ss.str();
875}
876
877std::string to_string(const VkRenderPassBeginInfo &vk_render_pass_begin_info,
878 int indentation_level)
879{
880 std::stringstream ss;
881 ss << "render_pass=" << to_string(vk_render_pass_begin_info.renderPass);
882 ss << ", framebuffer=" << to_string(vk_render_pass_begin_info.framebuffer);
883 ss << ", render_area=" << std::endl;
884 ss << std::string(indentation_level * 2 + 2, ' ')
885 << to_string(vk_render_pass_begin_info.renderArea, indentation_level + 1);
886 ss << std::string(indentation_level * 2, ' ');
887 ss << ", clear_value_count=" << vk_render_pass_begin_info.clearValueCount;
888 /*ss << ", p_clear_values=" << vk_render_pass_begin_info.pClearValues;*/
889
890 return ss.str();
891}
892
893std::string to_string(const VkRenderingAttachmentInfo &vk_rendering_attachment_info,
894 int indentation_level)
895{
896 UNUSED_VARS(indentation_level);
897 std::stringstream ss;
898 ss << "image_view=" << to_string(vk_rendering_attachment_info.imageView);
899 ss << ", image_layout=" << to_string(vk_rendering_attachment_info.imageLayout);
900 ss << ", resolve_mode=" << to_string(vk_rendering_attachment_info.resolveMode);
901 ss << ", resolve_image_view=" << to_string(vk_rendering_attachment_info.resolveImageView);
902 ss << ", resolve_image_layout=" << to_string(vk_rendering_attachment_info.resolveImageLayout);
903 ss << ", load_op=" << to_string(vk_rendering_attachment_info.loadOp);
904 ss << ", store_op=" << to_string(vk_rendering_attachment_info.storeOp);
905
906 return ss.str();
907}
908
909std::string to_string(const VkRenderingInfo &vk_rendering_info, int indentation_level)
910{
911 std::stringstream ss;
912 ss << "flags=" << to_string_vk_rendering_flags(vk_rendering_info.flags);
913 ss << ", render_area=" << std::endl;
914 ss << std::string(indentation_level * 2 + 2, ' ')
915 << to_string(vk_rendering_info.renderArea, indentation_level + 1);
916 ss << std::string(indentation_level * 2, ' ');
917 ss << ", layer_count=" << vk_rendering_info.layerCount;
918 ss << ", view_mask=" << vk_rendering_info.viewMask;
919 ss << ", color_attachment_count=" << vk_rendering_info.colorAttachmentCount;
920 ss << ", p_color_attachments=" << std::endl;
921 for (const VkRenderingAttachmentInfo &vk_rendering_attachment : Span<VkRenderingAttachmentInfo>(
922 vk_rendering_info.pColorAttachments, vk_rendering_info.colorAttachmentCount))
923 {
924 ss << std::string(indentation_level * 2 + 2, ' ')
925 << to_string(vk_rendering_attachment, indentation_level + 1) << std::endl;
926 }
927 if (vk_rendering_info.pDepthAttachment != nullptr) {
928 ss << std::string(indentation_level * 2, ' ');
929 ss << ", p_depth_attachment=" << std::endl;
930 ss << std::string(indentation_level * 2 + 2, ' ')
931 << to_string(*vk_rendering_info.pDepthAttachment, indentation_level + 1);
932 ss << std::endl;
933 }
934 if (vk_rendering_info.pStencilAttachment != nullptr) {
935 ss << std::string(indentation_level * 2, ' ');
936 ss << ", p_stencil_attachment=" << std::endl;
937 ss << std::string(indentation_level * 2 + 2, ' ')
938 << to_string(*vk_rendering_info.pStencilAttachment, indentation_level + 1);
939 ss << std::endl;
940 }
941
942 return ss.str();
943}
944
945} // namespace blender::gpu
#define UNUSED_VARS(...)
#define STRINGIFY(x)
#define STRINGIFY_ARG(x)
unsigned long long int uint64_t
const char * to_string(ShaderStage stage)
Definition mtl_shader.mm:52
std::string to_string_vk_rendering_flags(const VkRenderingFlags vk_rendering_flags)
std::string to_string_vk_dependency_flags(const VkDependencyFlags vk_dependency_flags)
std::string to_string_vk_shader_stage_flags(const VkShaderStageFlags vk_shader_stage_flags)
std::string to_string_vk_image_aspect_flags(const VkImageAspectFlags vk_image_aspect_flags)
std::string to_string_vk_pipeline_stage_flags(const VkPipelineStageFlags vk_pipeline_stage_flags)
static std::string to_string_handle(uint64_t vk_handle)
std::string to_string_vk_access_flags(const VkAccessFlags vk_access_flags)
unsigned __int64 uint64_t
Definition BKE_text.h:91
string to_string(const char *str)
Definition string.cpp:202
#define FORMAT_ERROR(X)