impeller::InlinePassContext Class Reference

#include <inline_pass_context.h>

Classes
struct	RenderPassResult

Public Member Functions
	InlinePassContext (std::shared_ptr< Context > context, EntityPassTarget &pass_target, uint32_t pass_texture_reads, uint32_t entity_count, std::optional< RenderPassResult > collapsed_parent_pass=std::nullopt)
	~InlinePassContext ()
bool	IsValid () const
bool	IsActive () const
std::shared_ptr< Texture >	GetTexture ()
bool	EndPass ()
EntityPassTarget &	GetPassTarget () const
uint32_t	GetPassCount () const
RenderPassResult	GetRenderPass (uint32_t pass_depth)

Detailed Description

Definition at line 17 of file inline_pass_context.h.

Constructor & Destructor Documentation

InlinePassContext()

impeller::InlinePassContext::InlinePassContext	(	std::shared_ptr< Context >	context,
		EntityPassTarget &	pass_target,
		uint32_t	pass_texture_reads,
		uint32_t	entity_count,
		std::optional< RenderPassResult >	collapsed_parent_pass = std::nullopt
	)

Definition at line 17 of file inline_pass_context.cc.

    : context_(std::move(context)),
      pass_target_(pass_target),
      entity_count_(entity_count),
      total_pass_reads_(pass_texture_reads),
      is_collapsed_(collapsed_parent_pass.has_value()) {
  if (collapsed_parent_pass.has_value()) {
    pass_ = collapsed_parent_pass.value().pass;
  }
}

~InlinePassContext()

impeller::InlinePassContext::~InlinePassContext

(

)

Definition at line 33 of file inline_pass_context.cc.

                                      {
  if (!is_collapsed_) {
    EndPass();
  }
}

References EndPass().

Member Function Documentation

EndPass()

bool impeller::InlinePassContext::EndPass

(

)

Definition at line 54 of file inline_pass_context.cc.

                                {
  if (!IsActive()) {
    return true;
  }
 
  if (command_buffer_) {
    if (!command_buffer_->EncodeAndSubmit(pass_)) {
      VALIDATION_LOG
          << "Failed to encode and submit command buffer while ending "
             "render pass.";
      return false;
    }
  }
 
  pass_ = nullptr;
  command_buffer_ = nullptr;
 
  return true;
}

References IsActive(), and VALIDATION_LOG.

Referenced by ~InlinePassContext().

GetPassCount()

uint32_t impeller::InlinePassContext::GetPassCount

(

)

const

Definition at line 184 of file inline_pass_context.cc.

                                               {
  return pass_count_;
}

GetPassTarget()

EntityPassTarget & impeller::InlinePassContext::GetPassTarget

(

)

const

Definition at line 74 of file inline_pass_context.cc.

                                                         {
  return pass_target_;
}

GetRenderPass()

InlinePassContext::RenderPassResult impeller::InlinePassContext::GetRenderPass

(

uint32_t

pass_depth

)

Create a new render pass if one isn't active. This path will run the first time this method is called, but it'll also run if the pass has been previously ended via EndPass.

Definition at line 78 of file inline_pass_context.cc.

                         {
  if (IsActive()) {
    return {.pass = pass_};
  }
 
  /// Create a new render pass if one isn't active. This path will run the first
  /// time this method is called, but it'll also run if the pass has been
  /// previously ended via `EndPass`.
 
  command_buffer_ = context_->CreateCommandBuffer();
  if (!command_buffer_) {
    VALIDATION_LOG << "Could not create command buffer.";
    return {};
  }
 
  if (pass_target_.GetRenderTarget().GetColorAttachments().empty()) {
    VALIDATION_LOG << "Color attachment unexpectedly missing from the "
                      "EntityPass render target.";
    return {};
  }
 
  command_buffer_->SetLabel(
      "EntityPass Command Buffer: Depth=" + std::to_string(pass_depth) +
      " Count=" + std::to_string(pass_count_));
 
  RenderPassResult result;
  {
    // If the pass target has a resolve texture, then we're using MSAA.
    bool is_msaa = pass_target_.GetRenderTarget()
                       .GetColorAttachments()
                       .find(0)
                       ->second.resolve_texture != nullptr;
    if (pass_count_ > 0 && is_msaa) {
      result.backdrop_texture =
          pass_target_.Flip(*context_->GetResourceAllocator());
      if (!result.backdrop_texture) {
        VALIDATION_LOG << "Could not flip the EntityPass render target.";
      }
    }
  }
 
  // Find the color attachment a second time, since the target may have just
  // flipped.
  auto color0 =
      pass_target_.GetRenderTarget().GetColorAttachments().find(0)->second;
  bool is_msaa = color0.resolve_texture != nullptr;
 
  if (pass_count_ > 0) {
    // When MSAA is being used, we end up overriding the entire backdrop by
    // drawing the previous pass texture, and so we don't have to clear it and
    // can use kDontCare.
    color0.load_action = is_msaa ? LoadAction::kDontCare : LoadAction::kLoad;
  } else {
    color0.load_action = LoadAction::kClear;
  }
 
  color0.store_action =
      is_msaa ? StoreAction::kMultisampleResolve : StoreAction::kStore;
 
  auto stencil = pass_target_.GetRenderTarget().GetStencilAttachment();
  if (!stencil.has_value()) {
    VALIDATION_LOG << "Stencil attachment unexpectedly missing from the "
                      "EntityPass render target.";
    return {};
  }
 
  // Only clear the stencil if this is the very first pass of the
  // layer.
  stencil->load_action =
      pass_count_ > 0 ? LoadAction::kLoad : LoadAction::kClear;
  // If we're on the last pass of the layer, there's no need to store the
  // stencil because nothing needs to read it.
  stencil->store_action = pass_count_ == total_pass_reads_
                              ? StoreAction::kDontCare
                              : StoreAction::kStore;
  pass_target_.target_.SetStencilAttachment(stencil.value());
 
  pass_target_.target_.SetColorAttachment(color0, 0);
 
  pass_ = command_buffer_->CreateRenderPass(pass_target_.GetRenderTarget());
  if (!pass_) {
    VALIDATION_LOG << "Could not create render pass.";
    return {};
  }
  // Commands are fairly large (500B) objects, so re-allocation of the command
  // buffer while encoding can add a surprising amount of overhead. We make a
  // conservative npot estimate to avoid this case.
  pass_->ReserveCommands(Allocation::NextPowerOfTwoSize(entity_count_));
  pass_->SetLabel(
      "EntityPass Render Pass: Depth=" + std::to_string(pass_depth) +
      " Count=" + std::to_string(pass_count_));
 
  result.pass = pass_;
 
  if (!context_->GetCapabilities()->SupportsReadFromResolve() &&
      result.backdrop_texture ==
          result.pass->GetRenderTarget().GetRenderTargetTexture()) {
    VALIDATION_LOG << "EntityPass backdrop restore configuration is not valid "
                      "for the current graphics backend.";
  }
 
  ++pass_count_;
  return result;
}

References impeller::InlinePassContext::RenderPassResult::backdrop_texture, impeller::EntityPassTarget::Flip(), impeller::RenderTarget::GetColorAttachments(), impeller::EntityPassTarget::GetRenderTarget(), impeller::RenderTarget::GetStencilAttachment(), IsActive(), impeller::kClear, impeller::kDontCare, impeller::kLoad, impeller::kMultisampleResolve, impeller::kStore, impeller::Allocation::NextPowerOfTwoSize(), impeller::InlinePassContext::RenderPassResult::pass, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetStencilAttachment(), and VALIDATION_LOG.

GetTexture()

std::shared_ptr< Texture > impeller::InlinePassContext::GetTexture

(

)

Definition at line 47 of file inline_pass_context.cc.

                                                     {
  if (!IsValid()) {
    return nullptr;
  }
  return pass_target_.GetRenderTarget().GetRenderTargetTexture();
}

References impeller::EntityPassTarget::GetRenderTarget(), impeller::RenderTarget::GetRenderTargetTexture(), and IsValid().

IsActive()

bool impeller::InlinePassContext::IsActive

(

)

const

Definition at line 43 of file inline_pass_context.cc.

                                       {
  return pass_ != nullptr;
}

Referenced by EndPass(), and GetRenderPass().

IsValid()

bool impeller::InlinePassContext::IsValid

(

)

const

Definition at line 39 of file inline_pass_context.cc.

                                      {
  return pass_target_.IsValid();
}

References impeller::EntityPassTarget::IsValid().

Referenced by GetTexture().

---

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

• impeller/entity/inline_pass_context.h
• impeller/entity/inline_pass_context.cc