Blender V5.3
vk_common.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_utildefines.hh"
10
11#include "GPU_texture.hh"
12#include "vk_backend.hh"
13#include "vk_common.hh"
14
15namespace blender::gpu {
16VkImageAspectFlags to_vk_image_aspect_flag_bits(const TextureFormat format)
17{
18 switch (format) {
19 /* Formats texture & render-buffer */
20 case TextureFormat::UINT_32_32_32_32:
21 case TextureFormat::UINT_32_32:
22 case TextureFormat::UINT_32:
23 case TextureFormat::UINT_16_16_16_16:
24 case TextureFormat::UINT_16_16:
25 case TextureFormat::UINT_16:
26 case TextureFormat::UINT_8_8_8_8:
27 case TextureFormat::UINT_8_8:
28 case TextureFormat::UINT_8:
29 case TextureFormat::SINT_32_32_32_32:
30 case TextureFormat::SINT_32_32:
31 case TextureFormat::SINT_32:
32 case TextureFormat::SINT_16_16_16_16:
33 case TextureFormat::SINT_16_16:
34 case TextureFormat::SINT_16:
35 case TextureFormat::SINT_8_8_8_8:
36 case TextureFormat::SINT_8_8:
37 case TextureFormat::SINT_8:
38 case TextureFormat::SFLOAT_32_32_32_32:
39 case TextureFormat::SFLOAT_32_32:
40 case TextureFormat::SFLOAT_32:
41 case TextureFormat::SFLOAT_16_16_16_16:
42 case TextureFormat::SFLOAT_16_16:
43 case TextureFormat::SFLOAT_16:
44 case TextureFormat::UNORM_16_16_16_16:
45 case TextureFormat::UNORM_16_16:
46 case TextureFormat::UNORM_16:
47 case TextureFormat::UNORM_8_8_8_8:
48 case TextureFormat::UNORM_8_8:
49 case TextureFormat::UNORM_8:
50 return VK_IMAGE_ASPECT_COLOR_BIT;
51
52 /* Special formats texture & render-buffer */
53 case TextureFormat::UNORM_10_10_10_2:
54 case TextureFormat::UINT_10_10_10_2:
55 case TextureFormat::UFLOAT_11_11_10:
56 case TextureFormat::SRGBA_8_8_8_8:
57 return VK_IMAGE_ASPECT_COLOR_BIT;
58
59 /* Depth Formats. */
60 case TextureFormat::SFLOAT_32_DEPTH:
61 case TextureFormat::UNORM_16_DEPTH:
62 return VK_IMAGE_ASPECT_DEPTH_BIT;
63
64 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
65 return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
66
67 /* Texture only formats. */
68 case TextureFormat::UINT_32_32_32:
69 case TextureFormat::UINT_16_16_16:
70 case TextureFormat::UINT_8_8_8:
71 case TextureFormat::SINT_32_32_32:
72 case TextureFormat::SINT_16_16_16:
73 case TextureFormat::SINT_8_8_8:
74 case TextureFormat::UNORM_16_16_16:
75 case TextureFormat::UNORM_8_8_8:
76 case TextureFormat::SNORM_16_16_16_16:
77 case TextureFormat::SNORM_16_16_16:
78 case TextureFormat::SNORM_16_16:
79 case TextureFormat::SNORM_16:
80 case TextureFormat::SNORM_8_8_8_8:
81 case TextureFormat::SNORM_8_8_8:
82 case TextureFormat::SNORM_8_8:
83 case TextureFormat::SNORM_8:
84 case TextureFormat::SFLOAT_32_32_32:
85 case TextureFormat::SFLOAT_16_16_16:
86 return VK_IMAGE_ASPECT_COLOR_BIT;
87
88 /* Special formats, texture only. */
89 case TextureFormat::SRGB_DXT1:
90 case TextureFormat::SRGB_DXT3:
91 case TextureFormat::SRGB_DXT5:
92 case TextureFormat::SNORM_DXT1:
93 case TextureFormat::SNORM_DXT3:
94 case TextureFormat::SNORM_DXT5:
95 case TextureFormat::SRGBA_8_8_8:
96 case TextureFormat::UFLOAT_9_9_9_EXP_5:
97 return VK_IMAGE_ASPECT_COLOR_BIT;
98
101 break;
102 }
104 return 0;
105}
106
107VkImageAspectFlags to_vk_image_aspect_flag_bits(const GPUFrameBufferBits buffers)
108{
109 VkImageAspectFlags result = 0;
110 if (buffers & GPU_COLOR_BIT) {
111 result |= VK_IMAGE_ASPECT_COLOR_BIT;
112 }
113 if (buffers & GPU_DEPTH_BIT) {
114 result |= VK_IMAGE_ASPECT_DEPTH_BIT;
115 }
116 if (buffers & GPU_STENCIL_BIT) {
117 result |= VK_IMAGE_ASPECT_STENCIL_BIT;
118 }
119 return result;
120}
121
122TextureFormat to_gpu_format(const VkFormat format)
123{
124 switch (format) {
126 case VK_FORMAT_B8G8R8A8_UNORM:
127 return TextureFormat::UNORM_8_8_8_8;
128
129 case VK_FORMAT_R16G16B16A16_SFLOAT:
130 return TextureFormat::SFLOAT_16_16_16_16;
131
132 default:
134 }
135 return TextureFormat::SFLOAT_32_32_32_32;
136}
137
138std::string to_gpu_format_string(VkFormat format)
139{
140#define CASE(a, b, c, blender_enum, vk_enum, e, f, g, h) \
141 case VK_FORMAT_##vk_enum: \
142 return STRINGIFY(blender_enum);
143 switch (format) {
145
146 case VK_FORMAT_UNDEFINED:
147 return "UNDEFINED";
148
149 default:
151 break;
152 }
153#undef CASE
154 return "Invalid";
155}
156
157VkFormat to_vk_format(const TextureFormat format)
158{
159#define CASE(a, b, c, blender_enum, vk_enum, e, f, g, h) \
160 case TextureFormat::blender_enum: \
161 return VK_FORMAT_##vk_enum;
162
163 switch (format) {
166 break;
167 }
168#undef CASE
169 return VK_FORMAT_UNDEFINED;
170}
171
172static VkFormat to_vk_format_norm(const GPUVertCompType type, const uint32_t size)
173{
174 switch (type) {
175 case GPU_COMP_I8:
176 switch (size) {
177 case 1:
178 return VK_FORMAT_R8_SNORM;
179 case 2:
180 return VK_FORMAT_R8G8_SNORM;
181 case 3:
182 return VK_FORMAT_R8G8B8_SNORM;
183 case 4:
184 return VK_FORMAT_R8G8B8A8_SNORM;
185 case 16:
186 return VK_FORMAT_R8G8B8A8_SNORM;
187 default:
189 return VK_FORMAT_R8_SNORM;
190 }
191 break;
192
193 case GPU_COMP_U8:
194 switch (size) {
195 case 1:
196 return VK_FORMAT_R8_UNORM;
197 case 2:
198 return VK_FORMAT_R8G8_UNORM;
199 case 3:
201 case 4:
203 case 16:
205 default:
207 return VK_FORMAT_R8_UNORM;
208 }
209 break;
210
211 case GPU_COMP_I16:
212 switch (size) {
213 case 2:
214 return VK_FORMAT_R16_SNORM;
215 case 4:
216 return VK_FORMAT_R16G16_SNORM;
217 case 6:
218 return VK_FORMAT_R16G16B16_SNORM;
219 case 8:
220 return VK_FORMAT_R16G16B16A16_SNORM;
221 default:
223 return VK_FORMAT_R16_SNORM;
224 }
225 break;
226
227 case GPU_COMP_U16:
228 switch (size) {
229 case 2:
230 return VK_FORMAT_R16_UNORM;
231 case 4:
232 return VK_FORMAT_R16G16_UNORM;
233 case 6:
234 return VK_FORMAT_R16G16B16_UNORM;
235 case 8:
236 return VK_FORMAT_R16G16B16A16_UNORM;
237 default:
239 return VK_FORMAT_R16_UNORM;
240 }
241 break;
242
243 case GPU_COMP_I10:
244 BLI_assert(size == 4);
245 return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
246
247 case GPU_COMP_I32:
248 case GPU_COMP_U32:
249 case GPU_COMP_F32:
250 default:
251 break;
252 }
254 return VK_FORMAT_R32_SFLOAT;
255}
256
257static VkFormat to_vk_format_float(const GPUVertCompType type, const uint32_t size)
258{
259 switch (type) {
260 case GPU_COMP_F32:
261 switch (size) {
262 case 4:
263 return VK_FORMAT_R32_SFLOAT;
264 case 8:
265 return VK_FORMAT_R32G32_SFLOAT;
266 case 12:
267 return VK_FORMAT_R32G32B32_SFLOAT;
268 case 16:
269 return VK_FORMAT_R32G32B32A32_SFLOAT;
270 case 64:
271 return VK_FORMAT_R32G32B32A32_SFLOAT;
272 default:
274 return VK_FORMAT_R32_SFLOAT;
275 }
276
277 default:
278 break;
279 }
281 return VK_FORMAT_R32_SFLOAT;
282}
283
284static VkFormat to_vk_format_int(const GPUVertCompType type, const uint32_t size)
285{
286 switch (type) {
287 case GPU_COMP_I8:
288 switch (size) {
289 case 1:
290 return VK_FORMAT_R8_SINT;
291 case 2:
292 return VK_FORMAT_R8G8_SINT;
293 case 3:
294 return VK_FORMAT_R8G8B8_SINT;
295 case 4:
296 return VK_FORMAT_R8G8B8A8_SINT;
297 default:
299 return VK_FORMAT_R8_SINT;
300 }
301 break;
302
303 case GPU_COMP_U8:
304 switch (size) {
305 case 1:
306 return VK_FORMAT_R8_UINT;
307 case 2:
308 return VK_FORMAT_R8G8_UINT;
309 case 3:
310 return VK_FORMAT_R8G8B8_UINT;
311 case 4:
312 return VK_FORMAT_R8G8B8A8_UINT;
313 default:
315 return VK_FORMAT_R8_UINT;
316 }
317 break;
318
319 case GPU_COMP_I16:
320 switch (size) {
321 case 2:
322 return VK_FORMAT_R16_SINT;
323 case 4:
324 return VK_FORMAT_R16G16_SINT;
325 case 6:
326 return VK_FORMAT_R16G16B16_SINT;
327 case 8:
328 return VK_FORMAT_R16G16B16A16_SINT;
329 default:
331 return VK_FORMAT_R16_SINT;
332 }
333 break;
334
335 case GPU_COMP_U16:
336 switch (size) {
337 case 2:
338 return VK_FORMAT_R16_UINT;
339 case 4:
340 return VK_FORMAT_R16G16_UINT;
341 case 6:
342 return VK_FORMAT_R16G16B16_UINT;
343 case 8:
344 return VK_FORMAT_R16G16B16A16_UINT;
345 default:
347 return VK_FORMAT_R16_UINT;
348 }
349 break;
350
351 case GPU_COMP_I32:
352 switch (size) {
353 case 4:
354 return VK_FORMAT_R32_SINT;
355 case 8:
356 return VK_FORMAT_R32G32_SINT;
357 case 12:
358 return VK_FORMAT_R32G32B32_SINT;
359 case 16:
360 return VK_FORMAT_R32G32B32A32_SINT;
361 default:
363 return VK_FORMAT_R32_SINT;
364 }
365 break;
366
367 case GPU_COMP_U32:
368 switch (size) {
369 case 4:
370 return VK_FORMAT_R32_UINT;
371 case 8:
372 return VK_FORMAT_R32G32_UINT;
373 case 12:
374 return VK_FORMAT_R32G32B32_UINT;
375 case 16:
376 return VK_FORMAT_R32G32B32A32_UINT;
377 default:
379 return VK_FORMAT_R32_UINT;
380 }
381 break;
382
383 case GPU_COMP_F32:
384 switch (size) {
385 case 4:
386 return VK_FORMAT_R32_SINT;
387 case 8:
388 return VK_FORMAT_R32G32_SINT;
389 case 12:
390 return VK_FORMAT_R32G32B32_SINT;
391 case 16:
392 return VK_FORMAT_R32G32B32A32_SINT;
393 default:
395 return VK_FORMAT_R32_SINT;
396 }
397 break;
398
399 case GPU_COMP_I10:
400 BLI_assert(size == 4);
401 return VK_FORMAT_A2B10G10R10_SINT_PACK32;
402
403 default:
404 break;
405 }
406
408 return VK_FORMAT_R32_SFLOAT;
409}
410
411VkFormat to_vk_format(const GPUVertCompType type, const uint32_t size, GPUVertFetchMode fetch_mode)
412{
413 switch (fetch_mode) {
414 case GPU_FETCH_FLOAT:
415 return to_vk_format_float(type, size);
416 case GPU_FETCH_INT:
417 return to_vk_format_int(type, size);
418 break;
420 return to_vk_format_norm(type, size);
421 break;
422 default:
423 break;
424 }
425
427 return VK_FORMAT_R32_SFLOAT;
428}
429
430VkFormat to_vk_format(const shader::Type type)
431{
432 switch (type) {
434 return VK_FORMAT_R32_SFLOAT;
436 return VK_FORMAT_R32G32_SFLOAT;
438 return VK_FORMAT_R32G32B32_SFLOAT;
440 return VK_FORMAT_R32G32B32A32_SFLOAT;
442 return VK_FORMAT_R32_UINT;
444 return VK_FORMAT_R32G32_UINT;
446 return VK_FORMAT_R32G32B32_UINT;
448 return VK_FORMAT_R32G32B32A32_UINT;
450 return VK_FORMAT_R32_SINT;
452 return VK_FORMAT_R32G32_SINT;
454 return VK_FORMAT_R32G32B32_SINT;
456 return VK_FORMAT_R32G32B32A32_SINT;
458 return VK_FORMAT_R32G32B32A32_SFLOAT;
459
479 break;
480 }
481
483 return VK_FORMAT_R32G32B32A32_SFLOAT;
484}
485
486VkQueryType to_vk_query_type(const GPUQueryType query_type)
487{
488 switch (query_type) {
490 return VK_QUERY_TYPE_OCCLUSION;
491 }
493 return VK_QUERY_TYPE_OCCLUSION;
494}
495
496VkImageType to_vk_image_type(const GPUTextureType type)
497{
498 /* See
499 * https://vulkan.lunarg.com/doc/view/1.3.243.0/linux/1.3-extensions/vkspec.html#resources-image-views-compatibility
500 * for reference */
501 switch (type) {
502 case GPU_TEXTURE_1D:
505 return VK_IMAGE_TYPE_1D;
506
507 case GPU_TEXTURE_2D:
509 case GPU_TEXTURE_CUBE:
511 return VK_IMAGE_TYPE_2D;
512
513 case GPU_TEXTURE_3D:
514 return VK_IMAGE_TYPE_3D;
515
517 /* GPU_TEXTURE_ARRAY should always be used together with 1D, 2D, or CUBE. */
518 break;
519 }
520
522 return VK_IMAGE_TYPE_1D;
523}
524
525VkImageViewType to_vk_image_view_type(const GPUTextureType type,
526 const eImageViewUsage view_type,
527 VKImageViewArrayed arrayed)
528{
529 VkImageViewType result = VK_IMAGE_VIEW_TYPE_1D;
530
531 switch (type) {
532 case GPU_TEXTURE_1D:
534 result = VK_IMAGE_VIEW_TYPE_1D;
535 break;
536 case GPU_TEXTURE_2D:
537 result = VK_IMAGE_VIEW_TYPE_2D;
538 break;
539 case GPU_TEXTURE_3D:
540 result = VK_IMAGE_VIEW_TYPE_3D;
541 break;
542 case GPU_TEXTURE_CUBE:
543 result = view_type == eImageViewUsage::Attachment ? VK_IMAGE_VIEW_TYPE_2D_ARRAY :
544 VK_IMAGE_VIEW_TYPE_CUBE;
545 break;
547 result = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
548 break;
550 result = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
551 break;
553 result = view_type == eImageViewUsage::Attachment ? VK_IMAGE_VIEW_TYPE_2D_ARRAY :
554 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
555 break;
556
558 /* GPU_TEXTURE_ARRAY should always be used together with 1D, 2D, or CUBE. */
559 break;
560 }
561
562 if (arrayed == VKImageViewArrayed::NOT_ARRAYED) {
563 if (result == VK_IMAGE_VIEW_TYPE_1D_ARRAY) {
564 result = VK_IMAGE_VIEW_TYPE_1D;
565 }
566 else if (result == VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
567 result = VK_IMAGE_VIEW_TYPE_2D;
568 }
569 else if (result == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
570 result = VK_IMAGE_VIEW_TYPE_CUBE;
571 }
572 }
573 else if (arrayed == VKImageViewArrayed::ARRAYED) {
574 if (result == VK_IMAGE_VIEW_TYPE_1D) {
575 result = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
576 }
577 else if (result == VK_IMAGE_VIEW_TYPE_2D) {
578 result = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
579 }
580 else if (result == VK_IMAGE_VIEW_TYPE_CUBE) {
581 result = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
582 }
583 }
584
585 return result;
586}
587
588VkComponentSwizzle to_vk_component_swizzle(const char swizzle)
589{
590 switch (swizzle) {
591 case '0':
592 return VK_COMPONENT_SWIZZLE_ZERO;
593 case '1':
594 return VK_COMPONENT_SWIZZLE_ONE;
595 case 'r':
596 return VK_COMPONENT_SWIZZLE_R;
597 case 'g':
598 return VK_COMPONENT_SWIZZLE_G;
599 case 'b':
600 return VK_COMPONENT_SWIZZLE_B;
601 case 'a':
602 return VK_COMPONENT_SWIZZLE_A;
603
604 default:
605 break;
606 }
608 return VK_COMPONENT_SWIZZLE_IDENTITY;
609}
610
611VkClearColorValue to_vk_clear_color_value(const eGPUDataFormat format, const double4 data)
612{
613 VkClearColorValue result = {{0.0f}};
614 switch (format) {
615 /* All float-like formats (i.e. everything except literal int/uint) go
616 * into VkClearColorValue float color fields. */
617 case GPU_DATA_FLOAT:
619 case GPU_DATA_UBYTE:
622 result.float32[0] = float(data[0]);
623 result.float32[1] = float(data[1]);
624 result.float32[2] = float(data[2]);
625 result.float32[3] = float(data[3]);
626 break;
627 }
628
629 case GPU_DATA_INT: {
630 result.int32[0] = int32_t(data[0]);
631 result.int32[1] = int32_t(data[1]);
632 result.int32[2] = int32_t(data[2]);
633 result.int32[3] = int32_t(data[3]);
634 break;
635 }
636
637 case GPU_DATA_UINT: {
638 result.uint32[0] = uint32_t(data[0]);
639 result.uint32[1] = uint32_t(data[1]);
640 result.uint32[2] = uint32_t(data[2]);
641 result.uint32[3] = uint32_t(data[3]);
642 break;
643 }
646 break;
647 }
648 }
649 return result;
650}
651
652VkIndexType to_vk_index_type(const GPUIndexBufType index_type)
653{
654 switch (index_type) {
655 case GPU_INDEX_U16:
656 return VK_INDEX_TYPE_UINT16;
657 case GPU_INDEX_U32:
658 return VK_INDEX_TYPE_UINT32;
659 default:
660 break;
661 }
663 return VK_INDEX_TYPE_UINT16;
664}
665
666VkPrimitiveTopology to_vk_primitive_topology(const GPUPrimType prim_type)
667{
668 switch (prim_type) {
669 case GPU_PRIM_POINTS:
670 return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
671 case GPU_PRIM_LINES:
672 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
673 case GPU_PRIM_TRIS:
674 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
676 return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
678 return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
680 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
681 case GPU_PRIM_TRI_FAN:
682 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
684 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
686 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
688 return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
689
690 case GPU_PRIM_NONE:
691 break;
692 }
693
695 return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
696}
697
698VkCullModeFlags to_vk_cull_mode_flags(const GPUFaceCullTest cull_test)
699{
700 switch (cull_test) {
701 case GPU_CULL_FRONT:
702 return VK_CULL_MODE_FRONT_BIT;
703 case GPU_CULL_BACK:
704 return VK_CULL_MODE_BACK_BIT;
705 case GPU_CULL_NONE:
706 return VK_CULL_MODE_NONE;
707 }
709 return VK_CULL_MODE_NONE;
710}
711
712VkSamplerAddressMode to_vk_sampler_address_mode(const GPUSamplerExtendMode extend_mode)
713{
714 switch (extend_mode) {
716 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
718 return VK_SAMPLER_ADDRESS_MODE_REPEAT;
720 return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
722 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
723 }
724
726 return VK_SAMPLER_ADDRESS_MODE_REPEAT;
727}
728
729static VkDescriptorType to_vk_descriptor_type_image(const shader::ImageType &image_type)
730{
731 switch (image_type) {
732 case shader::ImageType::Float1D:
733 case shader::ImageType::Float1DArray:
734 case shader::ImageType::Float2D:
735 case shader::ImageType::Float2DArray:
736 case shader::ImageType::Float3D:
737 case shader::ImageType::FloatCube:
738 case shader::ImageType::FloatCubeArray:
739 case shader::ImageType::Int1D:
740 case shader::ImageType::Int1DArray:
741 case shader::ImageType::Int2D:
742 case shader::ImageType::Int2DArray:
743 case shader::ImageType::Int3D:
744 case shader::ImageType::IntCube:
745 case shader::ImageType::IntCubeArray:
746 case shader::ImageType::AtomicInt2D:
747 case shader::ImageType::AtomicInt2DArray:
748 case shader::ImageType::AtomicInt3D:
749 case shader::ImageType::Uint1D:
750 case shader::ImageType::Uint1DArray:
751 case shader::ImageType::Uint2D:
752 case shader::ImageType::Uint2DArray:
753 case shader::ImageType::Uint3D:
754 case shader::ImageType::UintCube:
755 case shader::ImageType::UintCubeArray:
756 case shader::ImageType::AtomicUint2D:
757 case shader::ImageType::AtomicUint2DArray:
758 case shader::ImageType::AtomicUint3D:
759 return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
760
761 case shader::ImageType::FloatBuffer:
762 case shader::ImageType::IntBuffer:
763 case shader::ImageType::UintBuffer:
764 return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
765
766 default:
767 BLI_assert_msg(false, "ImageType not supported.");
768 }
769
770 return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
771}
772
773static VkDescriptorType to_vk_descriptor_type_sampler(const shader::ImageType &image_type)
774{
775 switch (image_type) {
777 case shader::ImageType::Float1D:
778 case shader::ImageType::Float1DArray:
779 case shader::ImageType::Float2D:
780 case shader::ImageType::Float2DArray:
781 case shader::ImageType::Float3D:
782 case shader::ImageType::FloatCube:
783 case shader::ImageType::FloatCubeArray:
784 case shader::ImageType::Int1D:
785 case shader::ImageType::Int1DArray:
786 case shader::ImageType::Int2D:
787 case shader::ImageType::Int2DArray:
788 case shader::ImageType::Int3D:
789 case shader::ImageType::IntCube:
790 case shader::ImageType::IntCubeArray:
791 case shader::ImageType::AtomicInt2D:
792 case shader::ImageType::AtomicInt2DArray:
793 case shader::ImageType::AtomicInt3D:
794 case shader::ImageType::Uint1D:
795 case shader::ImageType::Uint1DArray:
796 case shader::ImageType::Uint2D:
797 case shader::ImageType::Uint2DArray:
798 case shader::ImageType::Uint3D:
799 case shader::ImageType::UintCube:
800 case shader::ImageType::UintCubeArray:
801 case shader::ImageType::AtomicUint2D:
802 case shader::ImageType::AtomicUint2DArray:
803 case shader::ImageType::AtomicUint3D:
804 case shader::ImageType::Shadow2D:
805 case shader::ImageType::Shadow2DArray:
806 case shader::ImageType::ShadowCube:
807 case shader::ImageType::ShadowCubeArray:
808 case shader::ImageType::Depth2D:
809 case shader::ImageType::Depth2DArray:
810 case shader::ImageType::DepthCube:
811 case shader::ImageType::DepthCubeArray:
812 return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
813
814 case shader::ImageType::FloatBuffer:
815 case shader::ImageType::IntBuffer:
816 case shader::ImageType::UintBuffer:
817 return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
818 }
819
820 return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
821}
822
824{
825 switch (resource.bind_type) {
827 return to_vk_descriptor_type_image(resource.image.type);
829 return to_vk_descriptor_type_sampler(resource.sampler.type);
831 return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
833 return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
835 return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
836 }
838 return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
839}
840
842 const GPUTextureFormatFlag format_flag)
843{
844 /* sRGB textures are not directly writable as storage images. These need EXTENDED_USAGE to bind
845 * them as another format. Compressed formats have no storage capable format to bind as. */
846 return (usage & GPU_TEXTURE_USAGE_FORMAT_VIEW) && (format_flag & GPU_FORMAT_SRGB) &&
847 !(format_flag & GPU_FORMAT_COMPRESSED);
848}
849
850VkFormat vk_extended_usage_storage_image_format(const VkFormat format)
851{
852 /* sRGB textures are bound as UNORM 8 for storage images. */
853 switch (format) {
858 default:
859 break;
860 }
861 return format;
862}
863
864VkImageCreateFlags to_vk_image_create(const GPUTextureType texture_type,
865 const GPUTextureFormatFlag format_flag,
866 eGPUTextureUsage usage)
867{
868 VkImageCreateFlags result = 0;
869
870 if (ELEM(texture_type, GPU_TEXTURE_CUBE, GPU_TEXTURE_CUBE_ARRAY)) {
871 result |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
872 }
873
874 /* sRGB textures needs to be mutable as they can be used as non-sRGB frame-buffer attachments. */
875 if (usage & GPU_TEXTURE_USAGE_ATTACHMENT && format_flag & GPU_FORMAT_SRGB) {
876 result |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
877 }
878
879 if (usage & GPU_TEXTURE_USAGE_FORMAT_VIEW) {
880 result |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
881 }
882
883 /* The image's own format does not support storage usage, so it is bound as a storage image
884 * through a view with a different format. EXTENDED_USAGE lets the image keep the storage usage,
885 * by deferring the check to the view. The mutable format lets the view reinterpret the data. */
886 if (vk_need_extended_usage_for_storage_image(usage, format_flag)) {
887 result |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
888 }
889
890 return result;
891}
892
893VkImageUsageFlags to_vk_image_usage(const eGPUTextureUsage usage,
894 const GPUTextureFormatFlag format_flag,
895 bool use_image_host_copy)
896{
897 const VKDevice &device = VKBackend::get().device;
898 const VKExtensions &extensions = device.extensions_get();
899
900 VkImageUsageFlags result = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
901 if (usage & GPU_TEXTURE_USAGE_SHADER_READ) {
902 result |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
903 }
904 if (usage & GPU_TEXTURE_USAGE_SHADER_WRITE) {
905 result |= VK_IMAGE_USAGE_STORAGE_BIT;
906 }
907 if (usage & GPU_TEXTURE_USAGE_ATTACHMENT) {
908 if (format_flag & GPU_FORMAT_COMPRESSED) {
909 /* These formats aren't supported as an attachment. When using GPU_TEXTURE_USAGE_DEFAULT they
910 * are still being evaluated to be attachable. So we need to skip them. */
911 }
912 else {
913 if (format_flag & (GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL)) {
914 result |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
915 }
916 else {
917 result |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
918 result |= extensions.dynamic_rendering_local_read ? VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT :
919 VK_IMAGE_USAGE_SAMPLED_BIT;
920 }
921 }
922 }
923 if (usage & GPU_TEXTURE_USAGE_HOST_READ) {
924 result |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
925 }
926 if (use_image_host_copy) {
927 result |= VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT;
928 }
929
930 /* Disable some usages based on the given format flag to support more devices. */
931 if (format_flag & GPU_FORMAT_SRGB &&
932 !vk_need_extended_usage_for_storage_image(usage, format_flag))
933 {
934 /* NVIDIA devices don't create SRGB textures when the storage bit is set and
935 * EXTENDED_USAGE is not enabled. */
936 result &= ~VK_IMAGE_USAGE_STORAGE_BIT;
937 }
938 if (format_flag & (GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL)) {
939 /* NVIDIA devices don't create depth textures when it storage bit is set. */
940 result &= ~VK_IMAGE_USAGE_STORAGE_BIT;
941 }
942
943 return result;
944}
945
946} // namespace blender::gpu
#define CASE(a, size, c, blender_enum, d, e, f, g, h)
#define GPU_TEXTURE_TARGET_FORMAT_EXPAND(impl)
#define GPU_TEXTURE_FORMAT_EXPAND(impl)
#define BLI_assert_unreachable()
#define ELEM(...)
#define BLI_assert_msg(a, msg)
static VKBackend & get()
const VKExtensions & extensions_get() const
Definition vk_device.hh:398
#define VK_FORMAT_R8G8B8A8_UNORM
#define VK_FORMAT_R8G8B8_SRGB
#define VK_FORMAT_R8G8B8A8_SRGB
#define VK_FORMAT_R8G8B8_UNORM
VkQueryType to_vk_query_type(const GPUQueryType query_type)
Definition vk_common.cc:486
VkImageViewType to_vk_image_view_type(const GPUTextureType type, const eImageViewUsage view_type, VKImageViewArrayed arrayed)
Definition vk_common.cc:525
std::string to_gpu_format_string(VkFormat format)
Definition vk_common.cc:138
VkClearColorValue to_vk_clear_color_value(const eGPUDataFormat format, const double4 data)
Definition vk_common.cc:611
bool vk_need_extended_usage_for_storage_image(const eGPUTextureUsage usage, const GPUTextureFormatFlag format_flag)
Definition vk_common.cc:841
static VkFormat to_vk_format_norm(const GPUVertCompType type, const uint32_t size)
Definition vk_common.cc:172
VkImageUsageFlags to_vk_image_usage(const eGPUTextureUsage usage, const GPUTextureFormatFlag format_flag, bool use_image_host_copy)
Definition vk_common.cc:893
VkImageType to_vk_image_type(const GPUTextureType type)
Definition vk_common.cc:496
VkFormat to_vk_format(const TextureFormat format)
Definition vk_common.cc:157
static VkFormat to_vk_format_int(const GPUVertCompType type, const uint32_t size)
Definition vk_common.cc:284
VkIndexType to_vk_index_type(const GPUIndexBufType index_type)
Definition vk_common.cc:652
@ GPU_QUERY_OCCLUSION
Definition gpu_query.hh:18
VkComponentSwizzle to_vk_component_swizzle(const char swizzle)
Definition vk_common.cc:588
VkImageCreateFlags to_vk_image_create(const GPUTextureType texture_type, const GPUTextureFormatFlag format_flag, eGPUTextureUsage usage)
Definition vk_common.cc:864
static VkDescriptorType to_vk_descriptor_type_image(const shader::ImageType &image_type)
Definition vk_common.cc:729
static VkDescriptorType to_vk_descriptor_type_sampler(const shader::ImageType &image_type)
Definition vk_common.cc:773
VkDescriptorType to_vk_descriptor_type(const shader::ShaderCreateInfo::Resource &resource)
Definition vk_common.cc:823
VkSamplerAddressMode to_vk_sampler_address_mode(const GPUSamplerExtendMode extend_mode)
Definition vk_common.cc:712
VkPrimitiveTopology to_vk_primitive_topology(const GPUPrimType prim_type)
Definition vk_common.cc:666
VkCullModeFlags to_vk_cull_mode_flags(const GPUFaceCullTest cull_test)
Definition vk_common.cc:698
TextureFormat to_gpu_format(const VkFormat format)
Definition vk_common.cc:122
static VkFormat to_vk_format_float(const GPUVertCompType type, const uint32_t size)
Definition vk_common.cc:257
VkImageAspectFlags to_vk_image_aspect_flag_bits(const TextureFormat format)
Definition vk_common.cc:16
VkFormat vk_extended_usage_storage_image_format(const VkFormat format)
Definition vk_common.cc:850
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ GPU_CULL_FRONT
Definition GPU_state.hh:158
@ GPU_CULL_NONE
Definition GPU_state.hh:157
@ GPU_CULL_BACK
Definition GPU_state.hh:159
@ GPU_DATA_2_10_10_10_REV
@ GPU_DATA_HALF_FLOAT
@ GPU_DATA_10_11_11_REV
@ GPU_DATA_UINT_24_8_DEPRECATED
@ GPU_SAMPLER_EXTEND_MODE_MIRRORED_REPEAT
@ GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER
@ GPU_SAMPLER_EXTEND_MODE_REPEAT
@ GPU_SAMPLER_EXTEND_MODE_EXTEND
@ GPU_PRIM_TRI_STRIP
@ GPU_PRIM_TRIS_ADJ
@ GPU_PRIM_LINES_ADJ
@ GPU_PRIM_LINE_STRIP_ADJ
@ GPU_PRIM_LINE_STRIP
@ GPU_PRIM_LINE_LOOP
@ GPU_FETCH_INT_TO_FLOAT_UNIT
unsigned int uint32_t
Definition BKE_text.h:81
@ GPU_TEXTURE_USAGE_FORMAT_VIEW
@ GPU_TEXTURE_USAGE_SHADER_READ
@ GPU_TEXTURE_USAGE_SHADER_WRITE
@ GPU_TEXTURE_USAGE_HOST_READ
@ GPU_TEXTURE_USAGE_ATTACHMENT
BMesh const char void * data
signed int int32_t
Definition BKE_text.h:78
VecBase< double, 4 > double4
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float