impeller::InlinePassContext Class Reference

#include <inline_pass_context.h>

Public Member Functions
	InlinePassContext (const ContentContext &renderer, EntityPassTarget &pass_target)
	~InlinePassContext ()
bool	IsValid () const
bool	IsActive () const
std::shared_ptr< Texture >	GetTexture ()
bool	EndPass (bool is_onscreen=false)
EntityPassTarget &	GetPassTarget () const
uint32_t	GetPassCount () const
const std::shared_ptr< RenderPass > &	GetRenderPass ()

Detailed Description

Definition at line 17 of file inline_pass_context.h.

Constructor & Destructor Documentation

InlinePassContext()

impeller::InlinePassContext::InlinePassContext	(	const ContentContext &	renderer,
		EntityPassTarget &	pass_target
	)

Definition at line 20 of file inline_pass_context.cc.

    : renderer_(renderer), pass_target_(pass_target) {}

~InlinePassContext()

impeller::InlinePassContext::~InlinePassContext

(

)

Definition at line 24 of file inline_pass_context.cc.

                                      {
  EndPass();
}

References EndPass().

Member Function Documentation

EndPass()

bool impeller::InlinePassContext::EndPass

(

bool

is_onscreen = false

)

Definition at line 43 of file inline_pass_context.cc.

                                                {
  if (!IsActive()) {
    return true;
  }
  FML_DCHECK(command_buffer_);
 
  if (!pass_->EncodeCommands()) {
    VALIDATION_LOG << "Failed to encode and submit command buffer while ending "
                      "render pass.";
    return false;
  }
 
  const std::shared_ptr<Texture>& target_texture =
      GetPassTarget().GetRenderTarget().GetRenderTargetTexture();
  if (target_texture->GetMipCount() > 1) {
    fml::Status mip_status = AddMipmapGeneration(
        command_buffer_, renderer_.GetContext(), target_texture);
    if (!mip_status.ok()) {
      return false;
    }
  }
 
  pass_ = nullptr;
  if (is_onscreen) {
    return renderer_.GetContext()->SubmitOnscreen(std::move(command_buffer_));
  } else {
    return renderer_.GetContext()->EnqueueCommandBuffer(
        std::move(command_buffer_));
  }
}

References impeller::AddMipmapGeneration(), impeller::ContentContext::GetContext(), GetPassTarget(), impeller::EntityPassTarget::GetRenderTarget(), impeller::RenderTarget::GetRenderTargetTexture(), IsActive(), and VALIDATION_LOG.

Referenced by ~InlinePassContext().

GetPassCount()

uint32_t impeller::InlinePassContext::GetPassCount

(

)

const

Definition at line 157 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_;
}

Referenced by EndPass().

GetRenderPass()

const std::shared_ptr< RenderPass > & impeller::InlinePassContext::GetRenderPass

(

)

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_;
  }
 
  /// 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_ = renderer_.GetContext()->CreateCommandBuffer();
  if (!command_buffer_) {
    VALIDATION_LOG << "Could not create command buffer.";
    return pass_;
  }
 
  command_buffer_->SetLabel("EntityPass Command Buffer");
 
  {
    // If the pass target has a resolve texture, then we're using MSAA.
    bool is_msaa =
        pass_target_.GetRenderTarget().GetColorAttachment(0).resolve_texture !=
        nullptr;
    if (pass_count_ > 0 && is_msaa) {
      pass_target_.Flip(renderer_);
    }
  }
 
  // Find the color attachment a second time, since the target may have just
  // flipped.
  ColorAttachment color0 = pass_target_.GetRenderTarget().GetColorAttachment(0);
  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 depth = pass_target_.GetRenderTarget().GetDepthAttachment();
  if (!depth.has_value()) {
    VALIDATION_LOG << "Depth attachment unexpectedly missing from the "
                      "EntityPass render target.";
    return pass_;
  }
  depth->load_action = LoadAction::kClear;
  depth->store_action = StoreAction::kDontCare;
  pass_target_.target_.SetDepthAttachment(depth.value());
 
  auto stencil = pass_target_.GetRenderTarget().GetStencilAttachment();
  if (!depth.has_value() || !stencil.has_value()) {
    VALIDATION_LOG << "Stencil/Depth attachment unexpectedly missing from the "
                      "EntityPass render target.";
    return pass_;
  }
  stencil->load_action = LoadAction::kClear;
  stencil->store_action = StoreAction::kDontCare;
  depth->load_action = LoadAction::kClear;
  depth->store_action = StoreAction::kDontCare;
  pass_target_.target_.SetDepthAttachment(depth);
  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 pass_;
  }
  pass_->SetLabel("EntityPass Render Pass");
 
  ++pass_count_;
  return pass_;
}

References impeller::EntityPassTarget::Flip(), impeller::RenderTarget::GetColorAttachment(), impeller::ContentContext::GetContext(), impeller::RenderTarget::GetDepthAttachment(), impeller::EntityPassTarget::GetRenderTarget(), impeller::RenderTarget::GetStencilAttachment(), IsActive(), impeller::kClear, impeller::kDontCare, impeller::kLoad, impeller::kMultisampleResolve, impeller::kStore, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetDepthAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::Attachment::store_action, and VALIDATION_LOG.

GetTexture()

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

(

)

Definition at line 36 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 32 of file inline_pass_context.cc.

                                       {
  return pass_ != nullptr;
}

Referenced by EndPass(), and GetRenderPass().

IsValid()

bool impeller::InlinePassContext::IsValid

(

)

const

Definition at line 28 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