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