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;
46 if (resource_.vk_handle != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE) {
51 resource_.resource_handle = 0;
52 allocation_ = VK_NULL_HANDLE;
70 update_mipmaps.l0_size =
int3(1);
73 update_mipmaps.l0_size.y = 1;
74 update_mipmaps.l0_size.z = 1;
77 update_mipmaps.l0_size.z = 1;
82 context.render_graph().add_node(update_mipmaps);
87 VkImageAspectFlags vk_image_aspect)
97 copy_image.
node_data.
region.srcSubresource.aspectMask = vk_image_aspect;
101 copy_image.
node_data.
region.dstSubresource.aspectMask = vk_image_aspect;
109 context.render_graph().add_node(copy_image);
111 dst_texture.has_data_ =
true;
120 std::max(src->
d_, 1) == std::max(dst->
d_, 1));
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));
156 context.render_graph().add_node(clear_color_image);
164 std::optional<int>
layer)
170 vk_image_aspect_device;
171 if (vk_image_aspect == VK_IMAGE_ASPECT_NONE) {
186 if (
layer.has_value()) {
196 context.render_graph().add_node(clear_depth_stencil_image);
203 memcpy(swizzle_, swizzle_mask, 4);
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]);
212 const VkDeviceSize sample_bytesize =
to_bytesize(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();
223 constexpr uint64_t max_transferbuffer_bytesize = 2ul * 1024ul * 1024ul * 1024ul;
225 "Transfer buffer should at least fit all pixels of a single row.");
231 if (xyzl_bytesize <= max_transferbuffer_bytesize) {
233 transfer_regions.append(full_transfer_region);
237 for (
int layer : layers) {
238 if (xyz_bytesize <= max_transferbuffer_bytesize) {
243 if (xy_bytesize <= max_transferbuffer_bytesize) {
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);
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;
257 int64_t x_in_single_transfer = max_transferbuffer_bytesize / x_bytesize;
258 for (
int z = 0;
z < extent.z;
z++) {
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;
275 context.rendering_end();
276 for (
int index : transfer_regions.index_range()) {
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,
286 VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
287 VMA_ALLOCATION_CREATE_MAPPED_BIT,
290 "VKTexture::read_sub");
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;
307 node_data.
region.imageSubresource.baseArrayLayer = transfer_region.
layers.
start() +
309 node_data.
region.imageSubresource.layerCount = transfer_region.
layers.
size();
311 context.render_graph().add_node(copy_image_to_buffer);
320 for (
int index : transfer_regions.index_range()) {
325 size_t data_offset = full_transfer_region.result_offset(transfer_region.
offset,
327 host_sample_bytesize;
334 data_storage_format);
342 int mip_size[3] = {1, 1, 1};
345 switch (vk_image_type) {
346 case VK_IMAGE_TYPE_1D: {
350 case VK_IMAGE_TYPE_2D: {
353 case VK_IMAGE_TYPE_3D:
357 if (mip_size[2] == 0) {
361 int region[6] = {0, 0, 0, mip_size[0], mip_size[1], mip_size[2]};
371 const uint unpack_row_length)
378 int3 offset =
int3(offset_[0], offset_[1], offset_[2]);
383 start_layer = offset.y;
391 start_layer = offset.z;
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_);
405 BLI_assert_msg(extent.z == 1,
"Compressed 3D textures are not supported");
409 device_memory_size = blocks_x * blocks_y * block_size;
412 sample_len = device_memory_size /
to_bytesize(device_format_);
417 const bool is_sequential_packed =
ELEM(unpack_row_length, 0u,
uint(extent.x));
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();
430 const bool use_host_image_copy = !has_data_ &&
data !=
nullptr && allow_host_image_copy_;
431 if (use_host_image_copy) {
434 VkHostImageLayoutTransitionInfoEXT image_layout_transition = {
435 VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT,
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},
442 device.
functions.vkTransitionImageLayout(device.
vk_handle(), 1, &image_layout_transition);
444 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
447 VkMemoryToImageCopyEXT vk_memory_to_image_copy = {
448 VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,
454 {offset.x, offset.y, offset.z},
457 VkCopyMemoryToImageInfoEXT vk_copy_memory_to_image = {
458 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT,
460 VkHostImageCopyFlagsEXT(0),
462 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
464 &vk_memory_to_image_copy};
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,
481 "VKTexture::update_sub");
486 if (is_sequential_packed) {
494 "Compressed data with unpack_row_length != 0 is not supported.");
496 "3D texture data with unpack_row_length != 0 is not supported.");
497 size_t dst_row_stride = extent.x *
to_bytesize(device_format_);
501 for (
int y = 0;
y < extent.y;
y++) {
503 src_ptr += src_row_stride;
504 dst_ptr += dst_row_stride;
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;
530 node_data.
region.imageSubresource.layerCount = layers;
532 context.render_graph().add_node(copy_buffer_to_image);
541 const uint unpack_row_length)
543 update_sub(mip, offset, extent, format,
data,
nullptr, unpack_row_length);
549 GPUPixelBuffer *pixbuf)
552 update_sub(0, offset, extent, format,
nullptr, &pixel_buffer);
560 "Can only import external memory when usage flag contains GPU_TEXTURE_USAGE_MEMORY_EXPORT.");
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,
568 allocation_info_.deviceMemory,
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};
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,
580 allocation_info_.deviceMemory,
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};
596 if (device_format_ == TextureFormat::SFLOAT_16_16_16) {
597 device_format_ = TextureFormat::SFLOAT_16_16_16_16;
599 if (device_format_ == TextureFormat::SFLOAT_32_32_32) {
600 device_format_ = TextureFormat::SFLOAT_32_32_32_32;
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(
614 if (
bool(vk_format_properties3.optimalTilingFeatures &
615 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT))
623 VkImageFormatProperties image_format = {};
627 VK_IMAGE_TILING_OPTIMAL,
628 vk_image_usage_flags,
629 vk_image_create_flags,
631 allow_host_image_copy_ =
result == VK_SUCCESS;
649 source_buffer_ =
unwrap(vbo);
651 allow_host_image_copy_ =
false;
658 device_format_ =
texture->device_format_;
659 use_stencil_ = use_stencil;
661 allow_host_image_copy_ =
false;
670 device_format_ =
format_ = format;
673 resource_.vk_handle = vk_image;
689bool VKTexture::allocate()
694 VkExtent3D vk_extent = vk_extent_3d(0);
697 if (vk_extent.depth > limit || vk_extent.height > limit || vk_extent.depth > limit) {
704 VkImageCreateInfo image_info = {};
705 image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
708 image_info.extent = vk_extent;
717 image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
718 image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
721 vk_image_usage_ = image_info.usage;
722 image_info.samples = VK_SAMPLE_COUNT_1_BIT;
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;
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;
738 VkImageFormatProperties image_format = {};
739 result = vkGetPhysicalDeviceImageFormatProperties(device.physical_device_get(),
741 image_info.imageType,
746 if (
result != VK_SUCCESS) {
747 printf(
"Image type not supported on device.\n");
752 VkExternalMemoryImageCreateInfo external_memory_create_info = {
753 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
nullptr, 0};
755 VmaAllocationCreateInfo allocCreateInfo = {};
756 allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
760 external_memory_create_info.pNext = image_info.pNext;
761 image_info.pNext = &external_memory_create_info;
763 allocCreateInfo.pool = device.vma_pools.external_memory_image.pool;
767 allocCreateInfo.flags |= VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT;
768 allocCreateInfo.pUserData = (
void *)
name_.c_str();
771 result = vmaCreateImage(device.mem_allocator_get(),
774 &resource_.vk_handle,
777 if (
result != VK_SUCCESS) {
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());
786 return result == VK_SUCCESS;
789VkExtent3D VKTexture::vk_extent_3d(
int mip_level)
const
799 return VkExtent3D{
UNPACK3(extent)};
809 for (
const VKImageView &image_view : image_views_) {
810 if (image_view.info == info) {
816 return image_views_.last();
821 const VkImageAspectFlags allowed_bits = VK_IMAGE_ASPECT_COLOR_BIT |
822 (use_stencil_ ? VK_IMAGE_ASPECT_STENCIL_BIT :
823 VK_IMAGE_ASPECT_DEPTH_BIT);
839 {{
'r',
'g',
'b',
'a'}},
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];
#define BLI_assert_unreachable()
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
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
Texture * source_texture_
bool is_texture_view() 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_
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)
const VKResourceWithHandle< VkBuffer > & resource() const
void flush_mapped_memory()
void invalidate_mapped_memory()
void * mapped_memory_get() const
render_graph::VKResourceStateTracker resources
VkDevice vk_handle() const
const VKExtensions & extensions_get() const
VolkDeviceTable functions
VkPhysicalDevice physical_device_get() const
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
void generate_mipmap() override
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)
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)
VKCopyImageCreateInfo CreateInfo
void deref_resource(ResourceHandle resource_handle)
void update_image_layout(ResourceHandle image_handle, VkImageLayout vk_image_layout)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
void object_label(GLenum type, GLuint object, const char *name)
constexpr VkExternalMemoryHandleTypeFlags vk_external_memory_handle_type()
VkClearColorValue to_vk_clear_color_value(const eGPUDataFormat format, const double4 data)
bool vk_need_extended_usage_for_storage_image(const eGPUTextureUsage usage, const GPUTextureFormatFlag format_flag)
VkImageUsageFlags to_vk_image_usage(const eGPUTextureUsage usage, const GPUTextureFormatFlag format_flag, bool use_image_host_copy)
VkImageType to_vk_image_type(const GPUTextureType type)
VkFormat to_vk_format(const TextureFormat format)
VkImageCreateFlags to_vk_image_create(const GPUTextureType texture_type, const GPUTextureFormatFlag format_flag, eGPUTextureUsage usage)
eGPUDataFormat to_texture_data_format(TextureFormat tex_format)
static VkImageAspectFlags to_vk_image_aspect_single_bit(const VkImageAspectFlags format, bool stencil)
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.
VkImageAspectFlags to_vk_image_aspect_flag_bits(const TextureFormat format)
VkFormat vk_extended_usage_storage_image_format(const VkFormat format)
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
MINLINE int max_ii(int a, int b)
VecBase< uint32_t, 3 > uint3
int GPU_max_texture_size()
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
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
int64_t sample_count() const
VKImageViewArrayed arrayed
VkClearColorValue vk_clear_color_value
VkImageSubresourceRange vk_image_subresource_range
VKClearDepthStencilImageData node_data
VkImageAspectFlags vk_image_aspects
VkImageSubresourceRange vk_image_subresource_range
VkClearDepthStencilValue vk_clear_depth_stencil_value
VKCopyBufferToImageData node_data
VkImageAspectFlags vk_image_aspects
VKResourceWithHandle< VkBuffer > src_buffer
VKCopyImageData node_data
VkImageAspectFlags vk_image_aspect
int32_t mip_levels
The number of mip-levels to copy.
VKCopyImageToBufferData node_data
VkImageAspectFlags vk_image_aspects
VKResourceWithHandle< VkBuffer > dst_buffer
void resize(int new_size)