vk_texture.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2022 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "gpu_texture_private.hh"
 
#include "vk_context.hh"
#include "vk_image_view.hh"
#include "vk_memory.hh"
 
namespace blender::gpu {
 
class VKSampler;
class VKDescriptorSetTracker;
class VKVertexBuffer;
class VKPixelBuffer;

enum class VKImageViewFlags {
  DEFAULT = 0,
  NO_SWIZZLING = 1 << 0,
};
ENUM_OPERATORS(VKImageViewFlags, VKImageViewFlags::NO_SWIZZLING)
 
class VKTexture : public Texture {
  friend class VKDescriptorSetUpdator;
  friend class VKContext;

  TextureFormat device_format_ = TextureFormat::Invalid;

  VKTexture *source_texture_ = nullptr;

  VKVertexBuffer *source_buffer_ = nullptr;
  VkImage vk_image_ = VK_NULL_HANDLE;
  VmaAllocation allocation_ = VK_NULL_HANDLE;
  VmaAllocationInfo allocation_info_ = {};

  Vector<VKImageView> image_views_;
 
  int layer_offset_ = 0;
  bool use_stencil_ = false;
 
  char swizzle_[4] = {'r', 'g', 'b', 'a'};
  VKImageViewInfo image_view_info_ = {eImageViewUsage::ShaderBinding,
                                      IndexRange(0, VK_REMAINING_ARRAY_LAYERS),
                                      IndexRange(0, VK_REMAINING_MIP_LEVELS),
                                      {{'r', 'g', 'b', 'a'}},
                                      false,
                                      false,
                                      VKImageViewArrayed::DONT_CARE};
 
 public:
  VKTexture(const char *name) : Texture(name) {}
 
  virtual ~VKTexture() override;
 
  void generate_mipmap() override;
  void copy_to(Texture *tex) override;
  void copy_to(VKTexture &dst_texture, VkImageAspectFlags vk_image_aspect);
  void clear(eGPUDataFormat format, const void *data) override;
  void clear_depth_stencil(const GPUFrameBufferBits buffer,
                           float clear_depth,
                           uint clear_stencil,
                           std::optional<int> layer);
  void swizzle_set(const char swizzle_mask[4]) override;
  void mip_range_set(int min, int max) override;
  void *read(int mip, eGPUDataFormat format) override;
  void read_sub(
      int mip, eGPUDataFormat format, const int region[6], IndexRange layers, void *r_data);
  void update_sub(int mip,
                  int offset[3],
                  int extent[3],
                  eGPUDataFormat format,
                  const void *data,
                  VKPixelBuffer *pixel_buffer);
 
  void update_sub(
      int mip, int offset[3], int extent[3], eGPUDataFormat format, const void *data) override;
  void update_sub(int offset[3],
                  int extent[3],
                  eGPUDataFormat format,
                  GPUPixelBuffer *pixbuf) override;

  VKMemoryExport export_memory(VkExternalMemoryHandleTypeFlagBits handle_type);
 
  VkImage vk_image_handle() const
  {
    if (is_texture_view()) {
      return source_texture_->vk_image_handle();
    }
    BLI_assert(vk_image_ != VK_NULL_HANDLE);
    return vk_image_;
  }

  TextureFormat device_format_get() const
  {
    return device_format_;
  }

  const VKImageView &image_view_get(const VKImageViewInfo &info);

  const VKImageView &image_view_get(VKImageViewArrayed arrayed, VKImageViewFlags flags);
 
 protected:
  bool init_internal() override;
  bool init_internal(VertBuf *vbo) override;
  bool init_internal(gpu::Texture *src,
                     int mip_offset,
                     int layer_offset,
                     bool use_stencil) override;
  /* Initialize VKTexture with a swapchain image. */
  void init_swapchain(VkImage vk_image, TextureFormat gpu_format);
 
 private:
  bool is_texture_view() const;

  bool allocate();

  int vk_layer_count(int non_layered_value) const;

  VkExtent3D vk_extent_3d(int mip_level) const;
 
  /* -------------------------------------------------------------------- */
 
 private:
  IndexRange mip_map_range() const;
  IndexRange layer_range() const;

};
 
BLI_INLINE VKTexture *unwrap(Texture *tex)
{
  return static_cast<VKTexture *>(tex);
}
 
BLI_INLINE Texture *wrap(VKTexture *texture)
{
  return static_cast<Texture *>(texture);
}
 
}  // namespace blender::gpu