impeller::RenderPassVK Class Reference

#include <render_pass_vk.h>

Inheritance diagram for impeller::RenderPassVK:

Public Member Functions
	~RenderPassVK () override
Public Member Functions inherited from impeller::RenderPass
virtual	~RenderPass ()
const std::shared_ptr< const Context > &	GetContext () const
const RenderTarget &	GetRenderTarget () const
ISize	GetRenderTargetSize () const
const Matrix &	GetOrthographicTransform () const
void	SetLabel (std::string label)
bool	EncodeCommands () const
	Encode the recorded commands to the underlying command buffer.
virtual const std::vector< Command > &	GetCommands () const
	Accessor for the current Commands.
SampleCount	GetSampleCount () const
	The sample count of the attached render target.
PixelFormat	GetRenderTargetPixelFormat () const
	The pixel format of the attached render target.
bool	HasDepthAttachment () const
	Whether the render target has a depth attachment.
bool	HasStencilAttachment () const
	Whether the render target has an stencil attachment.
Public Member Functions inherited from impeller::ResourceBinder
virtual	~ResourceBinder ()=default

Private Member Functions
void	SetPipeline (const std::shared_ptr< Pipeline< PipelineDescriptor > > &pipeline) override
	The pipeline to use for this command.
void	SetCommandLabel (std::string_view label) override
	The debugging label to use for the command.
void	SetStencilReference (uint32_t value) override
void	SetBaseVertex (uint64_t value) override
void	SetViewport (Viewport viewport) override
void	SetScissor (IRect scissor) override
void	SetInstanceCount (size_t count) override
bool	SetVertexBuffer (VertexBuffer buffer) override
	Specify the vertex and index buffer to use for this command.
fml::Status	Draw () override
	Record the currently pending command.
void	ReserveCommands (size_t command_count) override
	Reserve [command_count] commands in the HAL command buffer.
bool	BindResource (ShaderStage stage, DescriptorType type, const ShaderUniformSlot &slot, const ShaderMetadata &metadata, BufferView view) override
bool	BindResource (ShaderStage stage, DescriptorType type, const ShaderUniformSlot &slot, const std::shared_ptr< const ShaderMetadata > &metadata, BufferView view) override
bool	BindResource (ShaderStage stage, DescriptorType type, const SampledImageSlot &slot, const ShaderMetadata &metadata, std::shared_ptr< const Texture > texture, const std::unique_ptr< const Sampler > &sampler) override
bool	IsValid () const override
void	OnSetLabel (std::string label) override
bool	OnEncodeCommands (const Context &context) const override

Friends
class	CommandBufferVK

Additional Inherited Members
Protected Member Functions inherited from impeller::RenderPass
bool	AddCommand (Command &&command)
	Record a command for subsequent encoding to the underlying command buffer. No work is encoded into the command buffer at this time.
	RenderPass (std::shared_ptr< const Context > context, const RenderTarget &target)
Protected Attributes inherited from impeller::RenderPass
const std::shared_ptr< const Context >	context_
const SampleCount	sample_count_
const PixelFormat	pixel_format_
const bool	has_depth_attachment_
const bool	has_stencil_attachment_
const ISize	render_target_size_
const RenderTarget	render_target_
std::vector< Command >	commands_
const Matrix	orthographic_

Detailed Description

Definition at line 22 of file render_pass_vk.h.

Constructor & Destructor Documentation

~RenderPassVK()

impeller::RenderPassVK::~RenderPassVK ( )

overridedefault

Member Function Documentation

BindResource() [1/3]

bool impeller::RenderPassVK::BindResource ( ShaderStage  stage, DescriptorType  type, const SampledImageSlot &  slot, const ShaderMetadata &  metadata, std::shared_ptr< const Texture >  texture, const std::unique_ptr< const Sampler > &  sampler  )

overrideprivatevirtual

Reimplemented from impeller::RenderPass.

Definition at line 585 of file render_pass_vk.cc.

                                                                             {
  if (bound_buffer_offset_ >= kMaxBindings) {
    return false;
  }
  if (!texture->IsValid() || !sampler) {
    return false;
  }
  const TextureVK& texture_vk = TextureVK::Cast(*texture);
  const SamplerVK& sampler_vk = SamplerVK::Cast(*sampler);
 
  if (!command_buffer_->GetEncoder()->Track(texture)) {
    return false;
  }
 
  if (!immutable_sampler_) {
    immutable_sampler_ = texture_vk.GetImmutableSamplerVariant(sampler_vk);
  }
 
  vk::DescriptorImageInfo image_info;
  image_info.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
  image_info.sampler = sampler_vk.GetSampler();
  image_info.imageView = texture_vk.GetImageView();
  image_workspace_[bound_image_offset_++] = image_info;
 
  vk::WriteDescriptorSet write_set;
  write_set.dstBinding = slot.binding;
  write_set.descriptorCount = 1u;
  write_set.descriptorType = vk::DescriptorType::eCombinedImageSampler;
  write_set.pImageInfo = &image_workspace_[bound_image_offset_ - 1];
 
  write_workspace_[descriptor_write_offset_++] = write_set;
  return true;
}

BindResource() [2/3]

bool impeller::RenderPassVK::BindResource ( ShaderStage  stage, DescriptorType  type, const ShaderUniformSlot &  slot, const ShaderMetadata &  metadata, BufferView  view  )

overrideprivatevirtual

Reimplemented from impeller::RenderPass.

Definition at line 533 of file render_pass_vk.cc.

                                                 {
  return BindResource(slot.binding, type, view);
}

BindResource() [3/3]

bool impeller::RenderPassVK::BindResource ( ShaderStage  stage, DescriptorType  type, const ShaderUniformSlot &  slot, const std::shared_ptr< const ShaderMetadata > &  metadata, BufferView  view  )

overrideprivatevirtual

Reimplemented from impeller::RenderPass.

Definition at line 541 of file render_pass_vk.cc.

                     {
  return BindResource(slot.binding, type, view);
}

Draw()

fml::Status impeller::RenderPassVK::Draw ( )

overrideprivatevirtual

Record the currently pending command.

If there are immutable samplers referenced in the render pass, the base pipeline variant is no longer valid and needs to be re-constructed to reference the samplers.

This is an instance of JIT creation of PSOs that can cause jank. It is unavoidable because it isn't possible to know all possible combinations of target YUV conversions. Fortunately, this will only ever happen when rendering to external textures. Like Android Hardware Buffers on Android.

Even when JIT creation is unavoidable, pipelines will cache their variants when able and all pipeline creation will happen via a base pipeline cache anyway. So the jank can be mostly entirely ameliorated and it should only ever happen when the first unknown YUV conversion is encountered.

Jank can be completely eliminated by pre-populating known YUV conversion pipelines.

Reimplemented from impeller::RenderPass.

Definition at line 425 of file render_pass_vk.cc.

                             {
  if (!pipeline_) {
    return fml::Status(fml::StatusCode::kCancelled,
                       "No valid pipeline is bound to the RenderPass.");
  }
 
  //----------------------------------------------------------------------------
  /// If there are immutable samplers referenced in the render pass, the base
  /// pipeline variant is no longer valid and needs to be re-constructed to
  /// reference the samplers.
  ///
  /// This is an instance of JIT creation of PSOs that can cause jank. It is
  /// unavoidable because it isn't possible to know all possible combinations of
  /// target YUV conversions. Fortunately, this will only ever happen when
  /// rendering to external textures. Like Android Hardware Buffers on Android.
  ///
  /// Even when JIT creation is unavoidable, pipelines will cache their variants
  /// when able and all pipeline creation will happen via a base pipeline cache
  /// anyway. So the jank can be mostly entirely ameliorated and it should only
  /// ever happen when the first unknown YUV conversion is encountered.
  ///
  /// Jank can be completely eliminated by pre-populating known YUV conversion
  /// pipelines.
  if (immutable_sampler_) {
    std::shared_ptr<PipelineVK> pipeline_variant =
        PipelineVK::Cast(*pipeline_)
            .CreateVariantForImmutableSamplers(immutable_sampler_);
    if (!pipeline_variant) {
      return fml::Status(
          fml::StatusCode::kAborted,
          "Could not create pipeline variant with immutable sampler.");
    }
    pipeline_ = pipeline_variant.get();
  }
 
  const auto& context_vk = ContextVK::Cast(*context_);
  const auto& pipeline_vk = PipelineVK::Cast(*pipeline_);
 
  auto descriptor_result =
      command_buffer_->GetEncoder()->AllocateDescriptorSets(
          pipeline_vk.GetDescriptorSetLayout(), context_vk);
  if (!descriptor_result.ok()) {
    return fml::Status(fml::StatusCode::kAborted,
                       "Could not allocate descriptor sets.");
  }
  const auto descriptor_set = descriptor_result.value();
  const auto pipeline_layout = pipeline_vk.GetPipelineLayout();
  command_buffer_vk_.bindPipeline(vk::PipelineBindPoint::eGraphics,
                                  pipeline_vk.GetPipeline());
 
  for (auto i = 0u; i < descriptor_write_offset_; i++) {
    write_workspace_[i].dstSet = descriptor_set;
  }
 
  context_vk.GetDevice().updateDescriptorSets(descriptor_write_offset_,
                                              write_workspace_.data(), 0u, {});
 
  command_buffer_vk_.bindDescriptorSets(
      vk::PipelineBindPoint::eGraphics,  // bind point
      pipeline_layout,                   // layout
      0,                                 // first set
      1,                                 // set count
      &descriptor_set,                   // sets
      0,                                 // offset count
      nullptr                            // offsets
  );
 
  if (pipeline_uses_input_attachments_) {
    InsertBarrierForInputAttachmentRead(
        command_buffer_vk_, TextureVK::Cast(*color_image_vk_).GetImage());
  }
 
  if (has_index_buffer_) {
    command_buffer_vk_.drawIndexed(vertex_count_,    // index count
                                   instance_count_,  // instance count
                                   0u,               // first index
                                   base_vertex_,     // vertex offset
                                   0u                // first instance
    );
  } else {
    command_buffer_vk_.draw(vertex_count_,    // vertex count
                            instance_count_,  // instance count
                            base_vertex_,     // vertex offset
                            0u                // first instance
    );
  }
 
#ifdef IMPELLER_DEBUG
  if (has_label_) {
    command_buffer_->GetEncoder()->PopDebugGroup();
  }
#endif  // IMPELLER_DEBUG
  has_label_ = false;
  has_index_buffer_ = false;
  bound_image_offset_ = 0u;
  bound_buffer_offset_ = 0u;
  descriptor_write_offset_ = 0u;
  instance_count_ = 1u;
  base_vertex_ = 0u;
  vertex_count_ = 0u;
  pipeline_ = nullptr;
  pipeline_uses_input_attachments_ = false;
  immutable_sampler_ = nullptr;
  return fml::Status();
}

IsValid()

bool impeller::RenderPassVK::IsValid ( ) const

overrideprivatevirtual

Implements impeller::RenderPass.

Definition at line 237 of file render_pass_vk.cc.

                                 {
  return is_valid_;
}

OnEncodeCommands()

bool impeller::RenderPassVK::OnEncodeCommands ( const Context &  context ) const

overrideprivatevirtual

Implements impeller::RenderPass.

Definition at line 624 of file render_pass_vk.cc.

                                                                {
  command_buffer_->GetEncoder()->GetCommandBuffer().endRenderPass();
 
  // If this render target will be consumed by a subsequent render pass,
  // perform a layout transition to a shader read state.
  const std::shared_ptr<Texture>& result_texture =
      resolve_image_vk_ ? resolve_image_vk_ : color_image_vk_;
  if (result_texture->GetTextureDescriptor().usage &
      TextureUsage::kShaderRead) {
    BarrierVK barrier;
    barrier.cmd_buffer = command_buffer_vk_;
    barrier.src_access = vk::AccessFlagBits::eColorAttachmentWrite |
                         vk::AccessFlagBits::eTransferWrite;
    barrier.src_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput |
                        vk::PipelineStageFlagBits::eTransfer;
    barrier.dst_access = vk::AccessFlagBits::eShaderRead;
    barrier.dst_stage = vk::PipelineStageFlagBits::eFragmentShader;
 
    barrier.new_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
 
    if (!TextureVK::Cast(*result_texture).SetLayout(barrier)) {
      return false;
    }
  }
 
  return true;
}

OnSetLabel()

void impeller::RenderPassVK::OnSetLabel ( std::string  label )

overrideprivatevirtual

Implements impeller::RenderPass.

Definition at line 241 of file render_pass_vk.cc.

                                             {
#ifdef IMPELLER_DEBUG
  ContextVK::Cast(*context_).SetDebugName(render_pass_->Get(),
                                          std::string(label).c_str());
#endif  // IMPELLER_DEBUG
}

ReserveCommands()

void impeller::RenderPassVK::ReserveCommands ( size_t  command_count )

inlineoverrideprivatevirtual

Reserve [command_count] commands in the HAL command buffer.

Note: this is not the native command buffer.

Reimplemented from impeller::RenderPass.

Definition at line 89 of file render_pass_vk.h.

{}

SetBaseVertex()

void impeller::RenderPassVK::SetBaseVertex ( uint64_t  value )

overrideprivatevirtual

Reimplemented from impeller::RenderPass.

Definition at line 344 of file render_pass_vk.cc.

                                               {
  base_vertex_ = value;
}

SetCommandLabel()

void impeller::RenderPassVK::SetCommandLabel ( std::string_view  label )

overrideprivatevirtual

The debugging label to use for the command.

Reimplemented from impeller::RenderPass.

Definition at line 330 of file render_pass_vk.cc.

                                                       {
#ifdef IMPELLER_DEBUG
  command_buffer_->GetEncoder()->PushDebugGroup(label);
  has_label_ = true;
#endif  // IMPELLER_DEBUG
}

SetInstanceCount()

void impeller::RenderPassVK::SetInstanceCount ( size_t  count )

overrideprivatevirtual

The number of instances of the given set of vertices to render. Not all backends support rendering more than one instance at a time.

Warning

Setting this to more than one will limit the availability of backends to use with this command.

Reimplemented from impeller::RenderPass.

Definition at line 369 of file render_pass_vk.cc.

                                                {
  instance_count_ = count;
}

SetPipeline()

void impeller::RenderPassVK::SetPipeline ( const std::shared_ptr< Pipeline< PipelineDescriptor > > &  pipeline )

overrideprivatevirtual

The pipeline to use for this command.

Reimplemented from impeller::RenderPass.

Definition at line 298 of file render_pass_vk.cc.

                                                                 {
  pipeline_ = pipeline.get();
  if (!pipeline_) {
    return;
  }
 
  pipeline_uses_input_attachments_ =
      pipeline_->GetDescriptor().GetVertexDescriptor()->UsesInputAttacments();
 
  if (pipeline_uses_input_attachments_) {
    if (bound_image_offset_ >= kMaxBindings) {
      pipeline_ = nullptr;
      return;
    }
    vk::DescriptorImageInfo image_info;
    image_info.imageLayout = vk::ImageLayout::eGeneral;
    image_info.sampler = VK_NULL_HANDLE;
    image_info.imageView = TextureVK::Cast(*color_image_vk_).GetImageView();
    image_workspace_[bound_image_offset_++] = image_info;
 
    vk::WriteDescriptorSet write_set;
    write_set.dstBinding = kMagicSubpassInputBinding;
    write_set.descriptorCount = 1u;
    write_set.descriptorType = vk::DescriptorType::eInputAttachment;
    write_set.pImageInfo = &image_workspace_[bound_image_offset_ - 1];
 
    write_workspace_[descriptor_write_offset_++] = write_set;
  }
}

SetScissor()

void impeller::RenderPassVK::SetScissor ( IRect  scissor )

overrideprivatevirtual

The scissor rect to use for clipping writes to the render target. The scissor rect must lie entirely within the render target. If unset, no scissor is applied.

Reimplemented from impeller::RenderPass.

Definition at line 360 of file render_pass_vk.cc.

                                           {
  vk::Rect2D scissor_vk =
      vk::Rect2D()
          .setOffset(vk::Offset2D(scissor.GetX(), scissor.GetY()))
          .setExtent(vk::Extent2D(scissor.GetWidth(), scissor.GetHeight()));
  command_buffer_vk_.setScissor(0, 1, &scissor_vk);
}

SetStencilReference()

void impeller::RenderPassVK::SetStencilReference ( uint32_t  value )

overrideprivatevirtual

The reference value to use in stenciling operations. Stencil configuration is part of pipeline setup and can be read from the pipelines descriptor.

See also

Pipeline

PipelineDescriptor

Reimplemented from impeller::RenderPass.

Definition at line 338 of file render_pass_vk.cc.

                                                     {
  command_buffer_vk_.setStencilReference(
      vk::StencilFaceFlagBits::eVkStencilFrontAndBack, value);
}

SetVertexBuffer()

bool impeller::RenderPassVK::SetVertexBuffer ( VertexBuffer  buffer )

overrideprivatevirtual

Specify the vertex and index buffer to use for this command.

Parameters

[in]

buffer

The vertex and index buffer definition. If possible, this value should be moved and not copied.

Returns

returns if the binding was updated.

Reimplemented from impeller::RenderPass.

Definition at line 374 of file render_pass_vk.cc.

                                                      {
  vertex_count_ = buffer.vertex_count;
  if (buffer.index_type == IndexType::kUnknown || !buffer.vertex_buffer) {
    return false;
  }
 
  if (!command_buffer_->GetEncoder()->Track(buffer.vertex_buffer.buffer)) {
    return false;
  }
 
  // Bind the vertex buffer.
  vk::Buffer vertex_buffer_handle =
      DeviceBufferVK::Cast(*buffer.vertex_buffer.buffer).GetBuffer();
  vk::Buffer vertex_buffers[] = {vertex_buffer_handle};
  vk::DeviceSize vertex_buffer_offsets[] = {buffer.vertex_buffer.range.offset};
 
  command_buffer_vk_.bindVertexBuffers(0u, 1u, vertex_buffers,
                                       vertex_buffer_offsets);
 
  // Bind the index buffer.
  if (buffer.index_type != IndexType::kNone) {
    has_index_buffer_ = true;
    const BufferView& index_buffer_view = buffer.index_buffer;
    if (!index_buffer_view) {
      return false;
    }
 
    const std::shared_ptr<const DeviceBuffer>& index_buffer =
        index_buffer_view.buffer;
    if (!index_buffer) {
      VALIDATION_LOG << "Failed to acquire device buffer"
                     << " for index buffer view";
      return false;
    }
 
    if (!command_buffer_->GetEncoder()->Track(index_buffer)) {
      return false;
    }
 
    vk::Buffer index_buffer_handle =
        DeviceBufferVK::Cast(*index_buffer).GetBuffer();
    command_buffer_vk_.bindIndexBuffer(index_buffer_handle,
                                       index_buffer_view.range.offset,
                                       ToVKIndexType(buffer.index_type));
  } else {
    has_index_buffer_ = false;
  }
  return true;
}

SetViewport()

void impeller::RenderPassVK::SetViewport ( Viewport  viewport )

overrideprivatevirtual

The viewport coordinates that the rasterizer linearly maps normalized device coordinates to. If unset, the viewport is the size of the render target with a zero origin, znear=0, and zfar=1.

Reimplemented from impeller::RenderPass.

Definition at line 349 of file render_pass_vk.cc.

                                                {
  vk::Viewport viewport_vk = vk::Viewport()
                                 .setWidth(viewport.rect.GetWidth())
                                 .setHeight(-viewport.rect.GetHeight())
                                 .setY(viewport.rect.GetHeight())
                                 .setMinDepth(0.0f)
                                 .setMaxDepth(1.0f);
  command_buffer_vk_.setViewport(0, 1, &viewport_vk);
}

Friends And Related Symbol Documentation

CommandBufferVK

friend class CommandBufferVK

friend

Definition at line 28 of file render_pass_vk.h.

---

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

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