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