Blender V5.3
vk_texture.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "GPU_capabilities.hh"
10
11/* vk_common needs to be included first to ensure win32 vulkan API is fully initialized, before
12 * working with it. */
13#include "GPU_texture.hh"
14#include "vk_common.hh"
15
16#include "vk_texture.hh"
17
18#include "vk_backend.hh"
19#include "vk_buffer.hh"
20#include "vk_context.hh"
21#include "vk_data_conversion.hh"
22#include "vk_framebuffer.hh"
23#include "vk_memory_layout.hh"
24#include "vk_pixel_buffer.hh"
25#include "vk_state_manager.hh"
26#include "vk_vertex_buffer.hh"
27
28#include "BKE_global.hh"
29
30namespace blender::gpu {
31
32static VkImageAspectFlags to_vk_image_aspect_single_bit(const VkImageAspectFlags format,
33 bool stencil)
34{
35 switch (format) {
36 case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT:
37 return (stencil) ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
38 default:
39 break;
40 }
41 return format;
42}
43
45{
46 if (resource_.vk_handle != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE) {
47 /* Release the owner reference; at zero ref count the image becomes discardable. */
48 VKDevice &device = VKBackend::get().device;
49 device.resources.deref_resource(resource_.resource_handle);
50 }
51 resource_.resource_handle = 0;
52 allocation_ = VK_NULL_HANDLE;
53}
54
56{
58 if (mipmaps_ <= 1) {
59 return;
60 }
61 /* Allow users to provide mipmaps stored in compressed textures.
62 * Skip generating mipmaps to avoid overriding the existing ones. */
64 return;
65 }
66
67 VKContext &context = *VKContext::get();
69 update_mipmaps.vk_image = vk_image_handle();
70 update_mipmaps.l0_size = int3(1);
71 mip_size_get(0, update_mipmaps.l0_size);
72 if (ELEM(this->type_get(), GPU_TEXTURE_1D_ARRAY)) {
73 update_mipmaps.l0_size.y = 1;
74 update_mipmaps.l0_size.z = 1;
75 }
76 else if (ELEM(this->type_get(), GPU_TEXTURE_2D_ARRAY)) {
77 update_mipmaps.l0_size.z = 1;
78 }
79 update_mipmaps.vk_image_aspect = to_vk_image_aspect_flag_bits(device_format_);
80 update_mipmaps.mipmaps = mipmaps_;
81 update_mipmaps.layer_count = layer_count();
82 context.render_graph().add_node(update_mipmaps);
83}
84
85void VKTexture::copy_to(VKTexture &dst_texture,
86 IndexRange mip_levels,
87 VkImageAspectFlags vk_image_aspect)
88{
89 if (mip_levels.is_empty()) {
90 return;
91 }
92
94 copy_image.node_data.mip_levels = uint32_t(mip_levels.size());
95 copy_image.node_data.src_image = vk_image_handle();
96 copy_image.node_data.dst_image = dst_texture.vk_image_handle();
97 copy_image.node_data.region.srcSubresource.aspectMask = vk_image_aspect;
98 copy_image.node_data.region.srcSubresource.mipLevel = mip_levels.first() + mip_min_;
99 copy_image.node_data.region.srcSubresource.layerCount = layer_count();
100 copy_image.node_data.region.srcSubresource.baseArrayLayer = view_layer_start_;
101 copy_image.node_data.region.dstSubresource.aspectMask = vk_image_aspect;
102 copy_image.node_data.region.dstSubresource.mipLevel = mip_levels.first() + dst_texture.mip_min_;
103 copy_image.node_data.region.dstSubresource.layerCount = dst_texture.layer_count();
104 copy_image.node_data.region.dstSubresource.baseArrayLayer = dst_texture.view_layer_start_;
105 copy_image.node_data.region.extent = vk_extent_3d(mip_levels.first());
106 copy_image.vk_image_aspect = vk_image_aspect;
107
108 VKContext &context = *VKContext::get();
109 context.render_graph().add_node(copy_image);
110
111 dst_texture.has_data_ = true;
112}
113
115{
116 VKTexture *dst = unwrap(texture);
117 VKTexture *src = this;
118
119 BLI_assert(src->w_ == dst->w_ && std::max(src->h_, 1) == std::max(dst->h_, 1) &&
120 std::max(src->d_, 1) == std::max(dst->d_, 1));
121 BLI_assert((src->format_ == dst->format_) ||
122 (src->format_ == TextureFormat::SRGBA_8_8_8_8 &&
123 dst->format_ == TextureFormat::UNORM_8_8_8_8) ||
124 (src->format_ == TextureFormat::UNORM_8_8_8_8 &&
125 dst->format_ == TextureFormat::SRGBA_8_8_8_8));
127
128 src->copy_to(*dst, mip_levels, to_vk_image_aspect_flag_bits(device_format_));
129}
130
132{
134
135 /* Relay depth/stencil clearing to clear_depth_stencil. This branch can be used by pyGPU. */
137 clear_depth_stencil(GPU_DEPTH_BIT, data.x, 0u, std::nullopt);
138 return;
139 }
140
142 clear_color_image.vk_clear_color_value = to_vk_clear_color_value(data_format, data);
143 clear_color_image.vk_image = vk_image_handle();
144 clear_color_image.vk_image_subresource_range.aspectMask = to_vk_image_aspect_flag_bits(
145 device_format_);
146
147 IndexRange layers = layer_range();
148 clear_color_image.vk_image_subresource_range.baseArrayLayer = layers.start();
149 clear_color_image.vk_image_subresource_range.layerCount = layers.size();
150 IndexRange levels = mip_map_range();
151 clear_color_image.vk_image_subresource_range.baseMipLevel = levels.start();
152 clear_color_image.vk_image_subresource_range.levelCount = levels.size();
153
154 VKContext &context = *VKContext::get();
155
156 context.render_graph().add_node(clear_color_image);
157
158 has_data_ = true;
159}
160
162 float clear_depth,
163 uint clear_stencil,
164 std::optional<int> layer)
165{
167 VkImageAspectFlags vk_image_aspect_device = to_vk_image_aspect_flag_bits(device_format_get());
168 VkImageAspectFlags vk_image_aspect = to_vk_image_aspect_flag_bits(
169 buffers & (GPU_DEPTH_BIT | GPU_STENCIL_BIT)) &
170 vk_image_aspect_device;
171 if (vk_image_aspect == VK_IMAGE_ASPECT_NONE) {
172 /* Early exit: texture doesn't have any aspect that needs to be cleared. */
173 return;
174 }
175
176 render_graph::VKClearDepthStencilImageNode::CreateInfo clear_depth_stencil_image = {};
177 clear_depth_stencil_image.node_data.vk_image = vk_image_handle();
178 clear_depth_stencil_image.vk_image_aspects = vk_image_aspect_device;
179 clear_depth_stencil_image.node_data.vk_clear_depth_stencil_value.depth = clear_depth;
180 clear_depth_stencil_image.node_data.vk_clear_depth_stencil_value.stencil = clear_stencil;
181 clear_depth_stencil_image.node_data.vk_image_subresource_range.aspectMask = vk_image_aspect;
182
183 IndexRange layers = layer_range();
184 clear_depth_stencil_image.node_data.vk_image_subresource_range.baseArrayLayer = layers.start();
185 clear_depth_stencil_image.node_data.vk_image_subresource_range.layerCount = layers.size();
186 if (layer.has_value()) {
187 clear_depth_stencil_image.node_data.vk_image_subresource_range.baseArrayLayer += *layer;
188 clear_depth_stencil_image.node_data.vk_image_subresource_range.layerCount = 1;
189 }
190
191 IndexRange levels = mip_map_range();
192 clear_depth_stencil_image.node_data.vk_image_subresource_range.baseMipLevel = levels.start();
193 clear_depth_stencil_image.node_data.vk_image_subresource_range.levelCount = levels.size();
194
195 VKContext &context = *VKContext::get();
196 context.render_graph().add_node(clear_depth_stencil_image);
197
198 has_data_ = true;
199}
200
201void VKTexture::swizzle_set(const char swizzle_mask[4])
202{
203 memcpy(swizzle_, swizzle_mask, 4);
204}
205
207 int mip, eGPUDataFormat format, const int region[6], const IndexRange layers, void *r_data)
208{
209 const int3 offset = int3(region[0], region[1], region[2]);
210 const int3 extent = int3(region[3] - region[0], region[4] - region[1], region[5] - region[2]);
211 TransferRegion full_transfer_region({offset, extent, layers});
212 const VkDeviceSize sample_bytesize = to_bytesize(device_format_);
213 const VkDeviceSize host_sample_bytesize = to_bytesize(format_, format);
214 /* For a texture view the raw bytes are reinterpretable with the base format but must be read
215 * back as the view (#format_) for them to be numerically correct. */
216 const TextureFormat data_storage_format = is_texture_view() ? format_ : device_format_;
217 const uint64_t x_bytesize = sample_bytesize * extent.x;
218 const uint64_t xy_bytesize = x_bytesize * extent.y;
219 const uint64_t xyz_bytesize = xy_bytesize * extent.z;
220 const uint64_t xyzl_bytesize = xyz_bytesize * layers.size();
221 /* #144887: Using a max transfer size of 2GB. NVIDIA doesn't seem to allocate transfer buffers
222 * larger than 4GB.*/
223 constexpr uint64_t max_transferbuffer_bytesize = 2ul * 1024ul * 1024ul * 1024ul;
224 BLI_assert_msg(x_bytesize < max_transferbuffer_bytesize,
225 "Transfer buffer should at least fit all pixels of a single row.");
226
227 /* Build a list of transfer regions to transfer the data back to the CPU, where the data can
228 * still be read as a continuous stream of data. This will reduce complexity during conversion.
229 */
230 Vector<TransferRegion> transfer_regions;
231 if (xyzl_bytesize <= max_transferbuffer_bytesize) {
232 /* All data fits in a single transfer buffer. */
233 transfer_regions.append(full_transfer_region);
234 }
235 else {
236 /* Always split by layer. */
237 for (int layer : layers) {
238 if (xyz_bytesize <= max_transferbuffer_bytesize) {
239 /* xyz data fits in a single transfer buffer. */
240 transfer_regions.append({offset, extent, IndexRange(layer, 1)});
241 }
242 else {
243 if (xy_bytesize <= max_transferbuffer_bytesize) {
244 /* Split by depth, transfer multiple depths at a time */
245 int64_t xy_in_single_transfer = max_transferbuffer_bytesize / xy_bytesize;
246 int depths_added = 0;
247 while (depths_added < extent.z) {
248 int3 offset_region(offset.x, offset.y, offset.z + depths_added);
249 int3 extent_region(
250 extent.x, extent.y, min_ii(xy_in_single_transfer, extent.z - depths_added));
251 transfer_regions.append({offset_region, extent_region, IndexRange(layer, 1)});
252 depths_added += extent_region.z;
253 }
254 }
255 else {
256 /* Split by depth and rows, transfer multiple rows at a time. */
257 int64_t x_in_single_transfer = max_transferbuffer_bytesize / x_bytesize;
258 for (int z = 0; z < extent.z; z++) {
259 int rows_added = 0;
260 while (rows_added < extent.y) {
261 int3 offset_region(offset.x, offset.y + rows_added, offset.z + z);
262 int3 extent_region(extent.x, min_ii(x_in_single_transfer, extent.y - rows_added), 1);
263 transfer_regions.append({offset_region, extent_region, IndexRange(layer, 1)});
264 rows_added += extent_region.y;
265 }
266 }
267 }
268 }
269 }
270 }
271
272 /* Create and schedule transfer regions. */
273 Array<VKBuffer> staging_buffers(transfer_regions.size());
274 VKContext &context = *VKContext::get();
275 context.rendering_end();
276 for (int index : transfer_regions.index_range()) {
277 const TransferRegion &transfer_region = transfer_regions[index];
278 VKBuffer &staging_buffer = staging_buffers[index];
279 size_t sample_len = transfer_region.sample_count();
280 size_t device_memory_size = sample_len * to_bytesize(device_format_);
281 staging_buffer.create(device_memory_size,
282 VK_BUFFER_USAGE_TRANSFER_DST_BIT,
283 VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
284 /* Although we are only reading, we need to set the host access random
285 * bit to improve the performance on AMD GPUs. */
286 VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
287 VMA_ALLOCATION_CREATE_MAPPED_BIT,
288 0.2f,
289 false,
290 "VKTexture::read_sub");
291
293 render_graph::VKCopyImageToBufferNode::Data &node_data = copy_image_to_buffer.node_data;
294 node_data.src_image = vk_image_handle();
295 node_data.dst_buffer = staging_buffer.resource();
296 node_data.region.imageOffset.x = transfer_region.offset.x;
297 node_data.region.imageOffset.y = transfer_region.offset.y;
298 node_data.region.imageOffset.z = transfer_region.offset.z;
299 node_data.region.imageExtent.width = transfer_region.extent.x;
300 node_data.region.imageExtent.height = transfer_region.extent.y;
301 node_data.region.imageExtent.depth = transfer_region.extent.z;
302 VkImageAspectFlags vk_image_aspects = to_vk_image_aspect_flag_bits(device_format_);
303 copy_image_to_buffer.vk_image_aspects = vk_image_aspects;
304 node_data.region.imageSubresource.aspectMask = to_vk_image_aspect_single_bit(vk_image_aspects,
305 false);
306 node_data.region.imageSubresource.mipLevel = mip + mip_min_;
307 node_data.region.imageSubresource.baseArrayLayer = transfer_region.layers.start() +
309 node_data.region.imageSubresource.layerCount = transfer_region.layers.size();
310
311 context.render_graph().add_node(copy_image_to_buffer);
312 }
313
314 /* Submit and wait for the transfers to be completed. */
315 context.flush_render_graph(RenderGraphFlushFlags::SUBMIT |
318
319 /* Convert the data to r_data. */
320 for (int index : transfer_regions.index_range()) {
321 const TransferRegion &transfer_region = transfer_regions[index];
322 VKBuffer &staging_buffer = staging_buffers[index];
323 size_t sample_len = transfer_region.sample_count();
324
325 size_t data_offset = full_transfer_region.result_offset(transfer_region.offset,
326 transfer_region.layers.start()) *
327 host_sample_bytesize;
328 staging_buffer.invalidate_mapped_memory();
329 convert_device_to_host(static_cast<void *>(static_cast<uint8_t *>(r_data) + data_offset),
330 staging_buffer.mapped_memory_get(),
331 sample_len,
332 format,
333 format_,
334 data_storage_format);
335 }
336}
337
338void VKTexture::read(int mip, eGPUDataFormat format, void *data)
339{
341
342 int mip_size[3] = {1, 1, 1};
343 VkImageType vk_image_type = to_vk_image_type(type_);
344 mip_size_get(mip, mip_size);
345 switch (vk_image_type) {
346 case VK_IMAGE_TYPE_1D: {
347 mip_size[1] = 1;
348 mip_size[2] = 1;
349 } break;
350 case VK_IMAGE_TYPE_2D: {
351 mip_size[2] = 1;
352 } break;
353 case VK_IMAGE_TYPE_3D:
354 default:
355 break;
356 }
357 if (mip_size[2] == 0) {
358 mip_size[2] = 1;
359 }
360
361 int region[6] = {0, 0, 0, mip_size[0], mip_size[1], mip_size[2]};
362 read_sub(mip, format, region, IndexRange(layer_count()), data);
363}
364
366 int offset_[3],
367 int extent_[3],
368 eGPUDataFormat format,
369 const void *data,
370 VKPixelBuffer *pixel_buffer,
371 const uint unpack_row_length)
372{
374
375 const bool is_compressed = (format_flag_ & GPU_FORMAT_COMPRESSED);
376
377 int3 extent = int3(extent_[0], max_ii(extent_[1], 1), max_ii(extent_[2], 1));
378 int3 offset = int3(offset_[0], offset_[1], offset_[2]);
379 int layers = 1;
380 int start_layer = 0;
381 if (type_ & GPU_TEXTURE_1D) {
382 layers = extent.y;
383 start_layer = offset.y;
384 extent.y = 1;
385 extent.z = 1;
386 offset.y = 0;
387 offset.z = 0;
388 }
390 layers = extent.z;
391 start_layer = offset.z;
392 extent.z = 1;
393 offset.z = 0;
394 }
395 BLI_assert(offset.x + extent.x <= width_get());
396 BLI_assert(offset.y + extent.y <= max_ii(height_get(), 1));
397 BLI_assert(offset.z + extent.z <= max_ii(depth_get(), 1));
398
399 /* Vulkan images cannot be directly mapped to host memory and requires a staging buffer. */
400 VKContext &context = *VKContext::get();
401 size_t sample_len = size_t(extent.x) * extent.y * extent.z * layers;
402 size_t device_memory_size = sample_len * to_bytesize(device_format_);
403
404 if (is_compressed) {
405 BLI_assert_msg(extent.z == 1, "Compressed 3D textures are not supported");
406 size_t block_size = to_block_size(device_format_);
407 size_t blocks_x = divide_ceil_u(extent.x, 4);
408 size_t blocks_y = divide_ceil_u(extent.y, 4);
409 device_memory_size = blocks_x * blocks_y * block_size;
410 /* `convert_buffer` later on will use `sample_len * to_bytesize(device_format_)`
411 * as total memory size calculation. Make that work for compressed case. */
412 sample_len = device_memory_size / to_bytesize(device_format_);
413 }
414
415 VKDevice &device = VKBackend::get().device;
416
417 const bool is_sequential_packed = ELEM(unpack_row_length, 0u, uint(extent.x));
418 /* Do conversion on CPU side. Allocating a staging buffer for these cases is less effective as
419 * it has overhead of the render graph, pipeline barriers and layout transitions. Staging
420 * buffers are optimized for sequential access which adds overhead when using multi-threading. */
421 const bool needs_data_conversion = needs_conversion(format, format_, device_format_);
422 Vector<uint8_t> device_compatible_data;
423 if (needs_data_conversion && is_sequential_packed) {
424 device_compatible_data.resize(device_memory_size);
426 device_compatible_data.data(), data, sample_len, format, format_, device_format_);
427 data = device_compatible_data.data();
428 }
429
430 const bool use_host_image_copy = !has_data_ && data != nullptr && allow_host_image_copy_;
431 if (use_host_image_copy) {
432 VkImageAspectFlags vk_image_aspects = to_vk_image_aspect_single_bit(
433 to_vk_image_aspect_flag_bits(device_format_), false);
434 VkHostImageLayoutTransitionInfoEXT image_layout_transition = {
435 VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT,
436 nullptr,
438 VK_IMAGE_LAYOUT_UNDEFINED,
439 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
440 {vk_image_aspects, 0, VK_REMAINING_MIP_LEVELS, 0, VK_REMAINING_ARRAY_LAYERS},
441 };
442 device.functions.vkTransitionImageLayout(device.vk_handle(), 1, &image_layout_transition);
443 device.resources.update_image_layout(resource_.resource_handle,
444 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
445 /* TODO: Add support for VK_HOST_IMAGE_COPY_MEMCPY_EXT flag. It would theoretically allow
446 * faster uploading, but requires sub resource to match our CPU layout. */
447 VkMemoryToImageCopyEXT vk_memory_to_image_copy = {
448 VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,
449 nullptr,
450 data,
451 unpack_row_length,
452 0,
453 {vk_image_aspects, uint32_t(mip), uint32_t(start_layer), uint32_t(layers)},
454 {offset.x, offset.y, offset.z},
455 {uint32_t(extent.x), uint32_t(extent.y), uint32_t(extent.z)}};
456
457 VkCopyMemoryToImageInfoEXT vk_copy_memory_to_image = {
458 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT,
459 nullptr,
460 VkHostImageCopyFlagsEXT(0),
462 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
463 1,
464 &vk_memory_to_image_copy};
465 device.functions.vkCopyMemoryToImage(device.vk_handle(), &vk_copy_memory_to_image);
466
467 has_data_ = true;
468 return;
469 }
470
471 VKBuffer staging_buffer;
473 if (data) {
474 staging_buffer.create(device_memory_size,
475 VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
476 VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
477 VMA_ALLOCATION_CREATE_MAPPED_BIT |
478 VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
479 0.4f,
480 false,
481 "VKTexture::update_sub");
482 buffer = staging_buffer.resource();
483 /* Rows are sequentially stored, when unpack row length is 0, or equal to the extent width. In
484 * other cases we unpack the rows to reduce the size of the staging buffer and data transfer.
485 */
486 if (is_sequential_packed) {
487 /* Data has already been converted, only need to copy.
488 * NOTE: Don't use multi-threaded copy as staging buffer is optimized for sequential access.
489 */
490 memcpy(staging_buffer.mapped_memory_get(), data, device_memory_size);
491 }
492 else {
493 BLI_assert_msg(!is_compressed,
494 "Compressed data with unpack_row_length != 0 is not supported.");
495 BLI_assert_msg(extent[2] <= 1,
496 "3D texture data with unpack_row_length != 0 is not supported.");
497 size_t dst_row_stride = extent.x * to_bytesize(device_format_);
498 size_t src_row_stride = unpack_row_length * to_bytesize(format_, format);
499 uint8_t *dst_ptr = static_cast<uint8_t *>(staging_buffer.mapped_memory_get());
500 const uint8_t *src_ptr = static_cast<const uint8_t *>(data);
501 for (int y = 0; y < extent.y; y++) {
502 convert_host_to_device(dst_ptr, src_ptr, extent.x, format, format_, device_format_);
503 src_ptr += src_row_stride;
504 dst_ptr += dst_row_stride;
505 }
506 }
507 staging_buffer.flush_mapped_memory();
508 }
509 else {
510 BLI_assert(pixel_buffer);
511 buffer = pixel_buffer->buffer_get().resource();
512 }
513
515 render_graph::VKCopyBufferToImageNode::Data &node_data = copy_buffer_to_image.node_data;
516 node_data.src_buffer = buffer;
517 node_data.dst_image = vk_image_handle();
518 node_data.region.imageExtent.width = extent.x;
519 node_data.region.imageExtent.height = extent.y;
520 node_data.region.imageExtent.depth = extent.z;
521 node_data.region.imageOffset.x = offset.x;
522 node_data.region.imageOffset.y = offset.y;
523 node_data.region.imageOffset.z = offset.z;
524 VkImageAspectFlags vk_image_aspects = to_vk_image_aspect_flag_bits(device_format_);
525 copy_buffer_to_image.vk_image_aspects = vk_image_aspects;
526 node_data.region.imageSubresource.aspectMask = to_vk_image_aspect_single_bit(vk_image_aspects,
527 false);
528 node_data.region.imageSubresource.mipLevel = mip + mip_min_;
529 node_data.region.imageSubresource.baseArrayLayer = start_layer + view_layer_start_;
530 node_data.region.imageSubresource.layerCount = layers;
531
532 context.render_graph().add_node(copy_buffer_to_image);
533 has_data_ = true;
534}
535
537 int offset[3],
538 int extent[3],
539 eGPUDataFormat format,
540 const void *data,
541 const uint unpack_row_length)
542{
543 update_sub(mip, offset, extent, format, data, nullptr, unpack_row_length);
544}
545
546void VKTexture::update_sub(int offset[3],
547 int extent[3],
548 eGPUDataFormat format,
549 GPUPixelBuffer *pixbuf)
550{
551 VKPixelBuffer &pixel_buffer = *unwrap(unwrap(pixbuf));
552 update_sub(0, offset, extent, format, nullptr, &pixel_buffer);
553}
554
555VKMemoryExport VKTexture::export_memory(VkExternalMemoryHandleTypeFlagBits handle_type)
556{
557 const VKDevice &device = VKBackend::get().device;
560 "Can only import external memory when usage flag contains GPU_TEXTURE_USAGE_MEMORY_EXPORT.");
561 BLI_assert_msg(allocation_ != nullptr,
562 "Cannot export memory when the texture is not backed by any device memory.");
564 "Requested to export memory, but isn't supported by the device");
565 if (handle_type == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) {
566 VkMemoryGetFdInfoKHR vk_memory_get_fd_info = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
567 nullptr,
568 allocation_info_.deviceMemory,
569 handle_type};
570 int fd_handle = 0;
571 device.functions.vkGetMemoryFdKHR(device.vk_handle(), &vk_memory_get_fd_info, &fd_handle);
572 return {uint64_t(fd_handle), allocation_info_.size, allocation_info_.offset};
573 }
574
575#ifdef _WIN32
576 if (handle_type == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
577 VkMemoryGetWin32HandleInfoKHR vk_memory_get_win32_handle_info = {
578 VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
579 nullptr,
580 allocation_info_.deviceMemory,
581 handle_type};
582 HANDLE win32_handle = nullptr;
583 device.functions.vkGetMemoryWin32HandleKHR(
584 device.vk_handle(), &vk_memory_get_win32_handle_info, &win32_handle);
585 return {uint64_t(win32_handle), allocation_info_.size, allocation_info_.offset};
586 }
587#endif
589 return {};
590}
591
593{
594 device_format_ = format_;
595 /* R16G16F16 formats are typically not supported (<1%). */
596 if (device_format_ == TextureFormat::SFLOAT_16_16_16) {
597 device_format_ = TextureFormat::SFLOAT_16_16_16_16;
598 }
599 if (device_format_ == TextureFormat::SFLOAT_32_32_32) {
600 device_format_ = TextureFormat::SFLOAT_32_32_32_32;
601 }
602
603 /* Identify if we can use VK_EXT_host_image_copy */
604 const VKDevice &device = VKBackend::get().device;
605 const VKExtensions &extensions = device.extensions_get();
606
607 if (extensions.host_image_copy) {
608 VkFormat vk_format = to_vk_format(device_format_);
609 VkFormatProperties3 vk_format_properties3 = {VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3};
610 VkFormatProperties2 vk_format_properties2 = {VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
611 &vk_format_properties3};
612 vkGetPhysicalDeviceFormatProperties2(
613 device.physical_device_get(), vk_format, &vk_format_properties2);
614 if (bool(vk_format_properties3.optimalTilingFeatures &
615 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT))
616 {
617 VkImageType vk_image_type = to_vk_image_type(type_);
618 VkImageUsageFlags vk_image_usage_flags = to_vk_image_usage(
620 VkImageCreateFlags vk_image_create_flags = to_vk_image_create(
622
623 VkImageFormatProperties image_format = {};
624 VkResult result = vkGetPhysicalDeviceImageFormatProperties(device.physical_device_get(),
625 vk_format,
626 vk_image_type,
627 VK_IMAGE_TILING_OPTIMAL,
628 vk_image_usage_flags,
629 vk_image_create_flags,
630 &image_format);
631 allow_host_image_copy_ = result == VK_SUCCESS;
632 }
633 }
634
635 if (!allocate()) {
636 return false;
637 }
638
639 mip_min_ = 0;
640 mip_max_ = mipmaps_ - 1;
641
642 return true;
643}
644
646{
647 BLI_assert(source_buffer_ == nullptr);
648 device_format_ = format_;
649 source_buffer_ = unwrap(vbo);
650 has_data_ = true;
651 allow_host_image_copy_ = false;
652 return true;
653}
654
655bool VKTexture::init_internal(gpu::Texture *src, bool use_stencil)
656{
658 device_format_ = texture->device_format_;
659 use_stencil_ = use_stencil;
660 has_data_ = true;
661 allow_host_image_copy_ = false;
662
663 return true;
664}
665
666void VKTexture::init_swapchain(VkImage vk_image,
668 TextureFormat format)
669{
670 device_format_ = format_ = format;
672 resource_.resource_handle = resource_handle;
673 resource_.vk_handle = vk_image;
676}
677
678static float memory_priority(const eGPUTextureUsage texture_usage)
679{
680 if (bool(texture_usage & GPU_TEXTURE_USAGE_MEMORY_EXPORT)) {
681 return 0.8f;
682 }
683 if (bool(texture_usage & GPU_TEXTURE_USAGE_ATTACHMENT)) {
684 return 1.0f;
685 }
686 return 0.5f;
687}
688
689bool VKTexture::allocate()
690{
691 BLI_assert(resource_.vk_handle == VK_NULL_HANDLE);
693
694 VkExtent3D vk_extent = vk_extent_3d(0);
697 if (vk_extent.depth > limit || vk_extent.height > limit || vk_extent.depth > limit) {
698 return false;
699 }
700
701 const eGPUTextureUsage texture_usage = usage_get();
702
703 VKDevice &device = VKBackend::get().device;
704 VkImageCreateInfo image_info = {};
705 image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
706 image_info.flags = to_vk_image_create(type_, format_flag_, texture_usage);
707 image_info.imageType = to_vk_image_type(type_);
708 image_info.extent = vk_extent;
709 image_info.mipLevels = max_ii(mipmaps_, 1);
710 image_info.arrayLayers = layer_count();
711 image_info.format = to_vk_format(device_format_);
712 /* Some platforms (NVIDIA) requires that attached textures are always tiled optimal.
713 *
714 * As image data are always accessed via an staging buffer we can enable optimal tiling for all
715 * texture. Tilings based on actual usages should be done in `VKFramebuffer`.
716 */
717 image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
718 image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
719 image_info.usage = to_vk_image_usage(
720 gpu_image_usage_flags_, format_flag_, allow_host_image_copy_);
721 vk_image_usage_ = image_info.usage;
722 image_info.samples = VK_SAMPLE_COUNT_1_BIT;
723
724 /* When this texture will be used with multiple formats, we need to provide them up front. */
725 VkFormat view_formats[2];
726 VkImageFormatListCreateInfo format_list_info = {VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO};
728 view_formats[0] = image_info.format;
729 view_formats[1] = vk_extended_usage_storage_image_format(image_info.format);
730 format_list_info.viewFormatCount = 2;
731 format_list_info.pViewFormats = view_formats;
732 format_list_info.pNext = image_info.pNext;
733 image_info.pNext = &format_list_info;
734 }
735
736 VkResult result;
737 if (G.debug & G_DEBUG_GPU) {
738 VkImageFormatProperties image_format = {};
739 result = vkGetPhysicalDeviceImageFormatProperties(device.physical_device_get(),
740 image_info.format,
741 image_info.imageType,
742 image_info.tiling,
743 image_info.usage,
744 image_info.flags,
745 &image_format);
746 if (result != VK_SUCCESS) {
747 printf("Image type not supported on device.\n");
748 return false;
749 }
750 }
751
752 VkExternalMemoryImageCreateInfo external_memory_create_info = {
753 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, nullptr, 0};
754
755 VmaAllocationCreateInfo allocCreateInfo = {};
756 allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
757 allocCreateInfo.priority = memory_priority(texture_usage);
758
759 if (bool(texture_usage & GPU_TEXTURE_USAGE_MEMORY_EXPORT)) {
760 external_memory_create_info.pNext = image_info.pNext;
761 image_info.pNext = &external_memory_create_info;
762 external_memory_create_info.handleTypes = vk_external_memory_handle_type();
763 allocCreateInfo.pool = device.vma_pools.external_memory_image.pool;
764 }
765
766 if (G.debug & G_DEBUG_GPU) {
767 allocCreateInfo.flags |= VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT;
768 allocCreateInfo.pUserData = (void *)name_.c_str();
769 }
770
771 result = vmaCreateImage(device.mem_allocator_get(),
772 &image_info,
773 &allocCreateInfo,
774 &resource_.vk_handle,
775 &allocation_,
776 &allocation_info_);
777 if (result != VK_SUCCESS) {
778 return false;
779 }
780 debug::object_label(resource_.vk_handle, name_.c_str());
781
782 const bool use_subresource_tracking = image_info.arrayLayers > 1 || image_info.mipLevels > 1;
783 resource_.resource_handle = device.resources.add_image(
784 resource_.vk_handle, use_subresource_tracking, allocation_, name_.c_str());
785
786 return result == VK_SUCCESS;
787}
788
789VkExtent3D VKTexture::vk_extent_3d(int mip_level) const
790{
791 uint3 extent = uint3(mip_size_get(mip_level));
793 extent[2] = 1;
794 }
796 extent[1] = 1;
797 extent[2] = 1;
798 }
799 return VkExtent3D{UNPACK3(extent)};
800}
801
803{
804 if (is_texture_view()) {
805 /* TODO: API should be improved as we don't support image view specialization.
806 * In the current API this is still possible to setup when using attachments. */
808 }
809 for (const VKImageView &image_view : image_views_) {
810 if (image_view.info == info) {
811 return image_view;
812 }
813 }
814
815 image_views_.append(VKImageView(*this, info, name_));
816 return image_views_.last();
817}
818
820{
821 const VkImageAspectFlags allowed_bits = VK_IMAGE_ASPECT_COLOR_BIT |
822 (use_stencil_ ? VK_IMAGE_ASPECT_STENCIL_BIT :
823 VK_IMAGE_ASPECT_DEPTH_BIT);
824 VkFormat vk_format = to_vk_format(device_format_);
826 format_ != static_cast<VKTexture *>(source_texture_)->format_)
827 {
828 vk_format = to_vk_format(format_);
829 }
830
831 /* For binding as a storage image, we may need to switch to another format. */
832 if (flag_is_set(flags, VKImageViewFlags::FOR_STORAGE_IMAGE)) {
833 vk_format = vk_extended_usage_storage_image_format(vk_format);
834 }
835
837 layer_range(),
839 {{'r', 'g', 'b', 'a'}},
840 arrayed,
841 vk_format,
842 to_vk_image_aspect_flag_bits(format_) & allowed_bits};
843
844 if (arrayed == VKImageViewArrayed::NOT_ARRAYED) {
845 image_view_info.layer_range = image_view_info.layer_range.slice(
847 }
848
849 if (!flag_is_set(flags, VKImageViewFlags::NO_SWIZZLING)) {
850 image_view_info.swizzle[0] = swizzle_[0];
851 image_view_info.swizzle[1] = swizzle_[1];
852 image_view_info.swizzle[2] = swizzle_[2];
853 image_view_info.swizzle[3] = swizzle_[3];
854 }
855
856 if (is_texture_view()) {
857 return static_cast<VKTexture *>(source_texture_)->image_view_get(image_view_info);
858 }
859 return image_view_get(image_view_info);
860}
861
862} // namespace blender::gpu
#define BLI_assert_unreachable()
#define UNPACK3(a)
#define ELEM(...)
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
constexpr int64_t first() const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange()=default
constexpr int64_t start() const
constexpr IndexRange slice(int64_t start, int64_t size) const
GPUTextureType type_get() const
IndexRange layer_range() const
eGPUTextureUsage gpu_image_usage_flags_
eGPUTextureUsage usage_get() const
IndexRange mip_map_range() const
void mip_size_get(int mip, int r_size[3]) const
void usage_set(eGPUTextureUsage usage_flags)
Texture(const char *name)
GPUTextureFormatFlag format_flag_
static VKBackend & get()
bool create(size_t size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage vma_memory_usage, VmaAllocationCreateFlags vma_allocation_flags, float priority, bool export_memory=false, const char *debug_name="VKBuffer", size_t alignment=0)
Definition vk_buffer.cc:29
const VKResourceWithHandle< VkBuffer > & resource() const
Definition vk_buffer.hh:104
void * mapped_memory_get() const
Definition vk_buffer.hh:158
static VKContext * get()
render_graph::VKResourceStateTracker resources
Definition vk_device.hh:270
VkDevice vk_handle() const
Definition vk_device.hh:338
const VKExtensions & extensions_get() const
Definition vk_device.hh:398
VolkDeviceTable functions
Definition vk_device.hh:280
VkPhysicalDevice physical_device_get() const
Definition vk_device.hh:289
VKImageView(VKTexture &texture, const VKImageViewInfo &info, StringRefNull name)
VKMemoryExport export_memory(VkExternalMemoryHandleTypeFlagBits handle_type)
void copy_to(Texture *texture, IndexRange mip_levels) override
void init_swapchain(VkImage vk_image, ResourceHandle resource_handle, TextureFormat gpu_format)
void clear_depth_stencil(const GPUFrameBufferBits buffer, float clear_depth, uint clear_stencil, std::optional< int > layer)
void update_sub(int mip, int offset[3], int extent[3], eGPUDataFormat format, const void *data, VKPixelBuffer *pixel_buffer, const uint unpack_row_length=0)
virtual ~VKTexture() override
Definition vk_texture.cc:44
void generate_mipmap() override
Definition vk_texture.cc:55
bool init_internal() override
TextureFormat device_format_get() const
void clear(const double4 data) override
VkImage vk_image_handle() const
const VKImageView & image_view_get(const VKImageViewInfo &info)
void swizzle_set(const char swizzle_mask[4]) override
VKTexture(const char *name)
Definition vk_texture.hh:81
void read(int mip, eGPUDataFormat format, void *data) override
ResourceHandle resource_handle() const
void read_sub(int mip, eGPUDataFormat format, const int region[6], IndexRange layers, void *r_data)
void update_image_layout(ResourceHandle image_handle, VkImageLayout vk_image_layout)
#define layer
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
void object_label(GLenum type, GLuint object, const char *name)
Definition gl_debug.cc:331
constexpr VkExternalMemoryHandleTypeFlags vk_external_memory_handle_type()
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
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
VkImageCreateFlags to_vk_image_create(const GPUTextureType texture_type, const GPUTextureFormatFlag format_flag, eGPUTextureUsage usage)
Definition vk_common.cc:864
eGPUDataFormat to_texture_data_format(TextureFormat tex_format)
static VkImageAspectFlags to_vk_image_aspect_single_bit(const VkImageAspectFlags format, bool stencil)
Definition vk_texture.cc:32
BLI_INLINE MTLTexture * unwrap(Texture *tex)
size_t to_block_size(TextureFormat data_type)
int to_bytesize(const DataFormat format)
void convert_host_to_device(void *dst_buffer, const void *src_buffer, size_t buffer_size, eGPUDataFormat host_format, TextureFormat host_texture_format, TextureFormat device_format)
bool needs_conversion(eGPUDataFormat host_format, TextureFormat host_texture_format, TextureFormat device_format)
Check if data conversion is needed when uploading host_format to a device_format.
uint64_t ResourceHandle
Definition vk_common.hh:68
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
static float memory_priority(const eGPUTextureUsage texture_usage)
void convert_device_to_host(void *dst_buffer, const void *src_buffer, size_t buffer_size, eGPUDataFormat host_format, TextureFormat host_texture_format, TextureFormat device_format)
GPUTextureFormatFlag to_format_flag(TextureFormat format)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
Definition BKE_text.h:91
__int64 int64_t
Definition BKE_text.h:90
unsigned int uint
Definition BKE_text.h:55
MINLINE int max_ii(int a, int b)
VecBase< uint32_t, 3 > uint3
int GPU_max_texture_size()
Global G
Definition blender.cc:57
unsigned int uint32_t
Definition BKE_text.h:81
VecBase< int32_t, 3 > int3
@ GPU_TEXTURE_USAGE_FORMAT_VIEW
@ GPU_TEXTURE_USAGE_MEMORY_EXPORT
@ GPU_TEXTURE_USAGE_SHADER_WRITE
@ GPU_TEXTURE_USAGE_ATTACHMENT
BMesh const char void * data
unsigned char uint8_t
Definition BKE_text.h:79
MINLINE uint divide_ceil_u(uint a, uint b)
int GPU_max_texture_3d_size()
MINLINE int min_ii(int a, int b)
VecBase< double, 4 > double4
int32_t mip_levels
The number of mip-levels to copy.
int size() const
Definition vector.hh:130
void resize(int new_size)
Definition vector.hh:94