impeller::BlitGenerateMipmapCommandVK Struct Reference

#include <blit_command_vk.h>

Inheritance diagram for impeller::BlitGenerateMipmapCommandVK:

Public Member Functions
	~BlitGenerateMipmapCommandVK () override
std::string	GetLabel () const override
bool	Encode (CommandEncoderVK &encoder) const override
Public Member Functions inherited from impeller::BlitEncodeVK
virtual	~BlitEncodeVK ()

Additional Inherited Members
Static Public Member Functions inherited from impeller::BackendCast< BlitEncodeVK, BlitCommand >
static BlitEncodeVK &	Cast (BlitCommand &base)
static const BlitEncodeVK &	Cast (const BlitCommand &base)
static BlitEncodeVK *	Cast (BlitCommand *base)
static const BlitEncodeVK *	Cast (const BlitCommand *base)
Public Attributes inherited from impeller::BlitGenerateMipmapCommand
std::shared_ptr< Texture >	texture
Public Attributes inherited from impeller::BlitCommand
std::string	label

Detailed Description

Definition at line 56 of file blit_command_vk.h.

Constructor & Destructor Documentation

~BlitGenerateMipmapCommandVK()

impeller::BlitGenerateMipmapCommandVK::~BlitGenerateMipmapCommandVK ( )

overridedefault

BlitGenerateMipmapCommandVK

Member Function Documentation

Encode()

bool impeller::BlitGenerateMipmapCommandVK::Encode ( CommandEncoderVK &  encoder ) const

overridevirtual

Implements impeller::BlitEncodeVK.

Definition at line 278 of file blit_command_vk.cc.

                                                                        {
  auto& src = TextureVK::Cast(*texture);
 
  const auto size = src.GetTextureDescriptor().size;
  uint32_t mip_count = src.GetTextureDescriptor().mip_count;
 
  if (mip_count < 2u) {
    return true;
  }
 
  const auto& image = src.GetImage();
  const auto& cmd = encoder.GetCommandBuffer();
 
  if (!encoder.Track(texture)) {
    return false;
  }
 
  // Initialize all mip levels to be in TransferDst mode. Later, in a loop,
  // after writing to that mip level, we'll first switch its layout to
  // TransferSrc to prepare the mip level after it, use the image as the source
  // of the blit, before finally switching it to ShaderReadOnly so its available
  // for sampling in a shader.
  InsertImageMemoryBarrier(
      cmd,                                   // command buffer
      image,                                 // image
      vk::AccessFlagBits::eTransferWrite,    // src access mask
      vk::AccessFlagBits::eTransferRead,     // dst access mask
      src.GetLayout(),                       // old layout
      vk::ImageLayout::eTransferDstOptimal,  // new layout
      vk::PipelineStageFlagBits::eTransfer,  // src stage
      vk::PipelineStageFlagBits::eTransfer,  // dst stage
      0u,                                    // mip level
      mip_count                              // mip level count
  );
 
  vk::ImageMemoryBarrier barrier;
  barrier.image = image;
  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
  barrier.subresourceRange.baseArrayLayer = 0;
  barrier.subresourceRange.layerCount = 1;
  barrier.subresourceRange.levelCount = 1;
 
  // Blit from the mip level N - 1 to mip level N.
  size_t width = size.width;
  size_t height = size.height;
  for (size_t mip_level = 1u; mip_level < mip_count; mip_level++) {
    barrier.subresourceRange.baseMipLevel = mip_level - 1;
    barrier.oldLayout = vk::ImageLayout::eTransferDstOptimal;
    barrier.newLayout = vk::ImageLayout::eTransferSrcOptimal;
    barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
    barrier.dstAccessMask = vk::AccessFlagBits::eTransferRead;
 
    // We just finished writing to the previous (N-1) mip level or it was the
    // base mip level. These were initialized to TransferDst earler. We are now
    // going to read from it to write to the current level (N) . So it must be
    // converted to TransferSrc.
    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                        vk::PipelineStageFlagBits::eTransfer, {}, {}, {},
                        {barrier});
 
    vk::ImageBlit blit;
    blit.srcSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
    blit.srcSubresource.baseArrayLayer = 0u;
    blit.srcSubresource.layerCount = 1u;
    blit.srcSubresource.mipLevel = mip_level - 1;
 
    blit.dstSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
    blit.dstSubresource.baseArrayLayer = 0u;
    blit.dstSubresource.layerCount = 1u;
    blit.dstSubresource.mipLevel = mip_level;
 
    // offsets[0] is origin.
    blit.srcOffsets[1].x = std::max<int32_t>(width, 1u);
    blit.srcOffsets[1].y = std::max<int32_t>(height, 1u);
    blit.srcOffsets[1].z = 1u;
 
    width = width / 2;
    height = height / 2;
 
    // offsets[0] is origin.
    blit.dstOffsets[1].x = std::max<int32_t>(width, 1u);
    blit.dstOffsets[1].y = std::max<int32_t>(height, 1u);
    blit.dstOffsets[1].z = 1u;
 
    cmd.blitImage(image,                                 // src image
                  vk::ImageLayout::eTransferSrcOptimal,  // src layout
                  image,                                 // dst image
                  vk::ImageLayout::eTransferDstOptimal,  // dst layout
                  1u,                                    // region count
                  &blit,                                 // regions
                  vk::Filter::eLinear                    // filter
    );
 
    barrier.oldLayout = vk::ImageLayout::eTransferSrcOptimal;
    barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
    barrier.srcAccessMask = vk::AccessFlagBits::eTransferRead;
    barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
    // Now that the blit is done, the image at the previous level (N-1)
    // is done reading from (TransferSrc)/ Now we must prepare it to be read
    // from a shader (ShaderReadOnly).
    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                        vk::PipelineStageFlagBits::eFragmentShader, {}, {}, {},
                        {barrier});
  }
 
  barrier.subresourceRange.baseMipLevel = mip_count - 1;
  barrier.oldLayout = vk::ImageLayout::eTransferDstOptimal;
  barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
  barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
  barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
  cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                      vk::PipelineStageFlagBits::eFragmentShader, {}, {}, {},
                      {barrier});
 
  // We modified the layouts of this image from underneath it. Tell it its new
  // state so it doesn't try to perform redundant transitions under the hood.
  src.SetLayoutWithoutEncoding(vk::ImageLayout::eShaderReadOnlyOptimal);
  src.SetMipMapGenerated();
 
  return true;
}

GetLabel()

std::string impeller::BlitGenerateMipmapCommandVK::GetLabel ( ) const

overridevirtual

Implements impeller::BlitEncodeVK.

Definition at line 274 of file blit_command_vk.cc.

                                                      {
  return label;
}

---

The documentation for this struct was generated from the following files:

• impeller/renderer/backend/vulkan/blit_command_vk.h
• impeller/renderer/backend/vulkan/blit_command_vk.cc