impeller::EntityPass Class Reference

#include <entity_pass.h>

Classes
struct	ClipCoverageLayer

Public Types
using	Element = std::variant< Entity, std::unique_ptr< EntityPass > >
using	BackdropFilterProc = std::function< std::shared_ptr< FilterContents >(FilterInput::Ref, const Matrix &effect_transform, Entity::RenderingMode rendering_mode)>
using	ClipCoverageStack = std::vector< ClipCoverageLayer >

Public Member Functions
	EntityPass ()
	~EntityPass ()
void	SetDelegate (std::shared_ptr< EntityPassDelegate > delgate)
void	SetBoundsLimit (std::optional< Rect > bounds_limit)
	Set the bounds limit, which is provided by the user when creating a SaveLayer. This is a hint that allows the user to communicate that it's OK to not render content outside of the bounds. More...
std::optional< Rect >	GetBoundsLimit () const
	Get the bounds limit, which is provided by the user when creating a SaveLayer. More...
size_t	GetSubpassesDepth () const
std::unique_ptr< EntityPass >	Clone () const
void	AddEntity (Entity entity)
	Add an entity to the current entity pass. More...
void	SetElements (std::vector< Element > elements)
EntityPass *	AddSubpass (std::unique_ptr< EntityPass > pass)
	Appends a given pass as a subpass. More...
void	AddSubpassInline (std::unique_ptr< EntityPass > pass)
	Merges a given pass into this pass. Useful for drawing pre-recorded pictures that don't require rendering into a separate subpass. More...
EntityPass *	GetSuperpass () const
bool	Render (ContentContext &renderer, const RenderTarget &render_target) const
void	IterateAllElements (const std::function< bool(Element &)> &iterator)
	Iterate all elements (entities and subpasses) in this pass, recursively including elements of child passes. The iteration order is depth-first. Whenever a subpass elements is encountered, it's included in the stream before its children. More...
void	IterateAllEntities (const std::function< bool(Entity &)> &iterator)
	Iterate all entities in this pass, recursively including entities of child passes. The iteration order is depth-first. More...
void	IterateAllEntities (const std::function< bool(const Entity &)> &iterator) const
	Iterate all entities in this pass, recursively including entities of child passes. The iteration order is depth-first and does not allow modification of the entities. More...
bool	IterateUntilSubpass (const std::function< bool(Entity &)> &iterator)
	Iterate entities in this pass up until the first subpass is found. This is useful for limiting look-ahead optimizations. More...
size_t	GetElementCount () const
	Return the number of elements on this pass. More...
void	SetTransform (Matrix transform)
void	SetClipDepth (size_t clip_depth)
size_t	GetClipDepth ()
void	SetBlendMode (BlendMode blend_mode)
std::optional< Color >	GetClearColor (ISize size=ISize::Infinite()) const
	Return the premultiplied clear color of the pass entities, if any. More...
Color	GetClearColorOrDefault (ISize size=ISize::Infinite()) const
	Return the premultiplied clear color of the pass entities. More...
void	SetBackdropFilter (BackdropFilterProc proc)
void	SetEnableOffscreenCheckerboard (bool enabled)
std::optional< Rect >	GetSubpassCoverage (const EntityPass &subpass, std::optional< Rect > coverage_limit) const
	Computes the coverage of a given subpass. This is used to determine the texture size of a given subpass before it's rendered to and passed through the subpass ImageFilter, if any. More...
std::optional< Rect >	GetElementsCoverage (std::optional< Rect > coverage_limit) const

Static Public Attributes
static const std::string	kCaptureDocumentName = "EntityPass"

Detailed Description

Definition at line 25 of file entity_pass.h.

Member Typedef Documentation

BackdropFilterProc

using impeller::EntityPass::BackdropFilterProc = std::function<std::shared_ptr<FilterContents>( FilterInput::Ref, const Matrix& effect_transform, Entity::RenderingMode rendering_mode)>

Definition at line 43 of file entity_pass.h.

ClipCoverageStack

using impeller::EntityPass::ClipCoverageStack = std::vector<ClipCoverageLayer>

Definition at line 50 of file entity_pass.h.

Element

using impeller::EntityPass::Element = std::variant<Entity, std::unique_ptr<EntityPass> >

Elements are renderable items in the EntityPass. Each can either be an Entity or a child EntityPass.

When the element is a child EntityPass, it may be rendered to an offscreen texture and converted into an Entity that draws the texture into the current pass, or its children may be collapsed into the current

EntityPass. Elements are converted to Entities in GetEntityForElement().

Definition at line 36 of file entity_pass.h.

Constructor & Destructor Documentation

EntityPass()

impeller::EntityPass::EntityPass ( )

default

~EntityPass()

impeller::EntityPass::~EntityPass ( )

default

Member Function Documentation

AddEntity()

void impeller::EntityPass::AddEntity

(

Entity

entity

)

Add an entity to the current entity pass.

Definition at line 70 of file entity_pass.cc.

                                        {
  if (entity.GetBlendMode() == BlendMode::kSourceOver &&
      entity.GetContents()->IsOpaque()) {
    entity.SetBlendMode(BlendMode::kSource);
  }
 
  if (entity.GetBlendMode() > Entity::kLastPipelineBlendMode) {
    advanced_blend_reads_from_pass_texture_ += 1;
  }
  elements_.emplace_back(std::move(entity));
}

References impeller::Entity::GetBlendMode(), impeller::Entity::GetContents(), impeller::Entity::kLastPipelineBlendMode, impeller::kSource, impeller::kSourceOver, and impeller::Entity::SetBlendMode().

Referenced by impeller::Canvas::DrawAtlas(), impeller::Canvas::DrawCircle(), impeller::Canvas::DrawImageRect(), impeller::Canvas::DrawLine(), impeller::Canvas::DrawOval(), impeller::Canvas::DrawPaint(), impeller::Canvas::DrawPath(), impeller::Canvas::DrawPoints(), impeller::Canvas::DrawRect(), impeller::Canvas::DrawRRect(), impeller::Canvas::DrawTextFrame(), impeller::Canvas::DrawVertices(), and impeller::testing::TEST_P().

AddSubpass()

EntityPass * impeller::EntityPass::AddSubpass

(

std::unique_ptr< EntityPass >

pass

)

Appends a given pass as a subpass.

Definition at line 205 of file entity_pass.cc.

                                                                 {
  if (!pass) {
    return nullptr;
  }
  FML_DCHECK(pass->superpass_ == nullptr);
  pass->superpass_ = this;
 
  if (pass->backdrop_filter_proc_) {
    backdrop_filter_reads_from_pass_texture_ += 1;
  }
  if (pass->blend_mode_ > Entity::kLastPipelineBlendMode) {
    advanced_blend_reads_from_pass_texture_ += 1;
  }
 
  auto subpass_pointer = pass.get();
  elements_.emplace_back(std::move(pass));
  return subpass_pointer;
}

References impeller::Entity::kLastPipelineBlendMode.

Referenced by impeller::testing::TEST_P().

AddSubpassInline()

void impeller::EntityPass::AddSubpassInline

(

std::unique_ptr< EntityPass >

pass

)

Merges a given pass into this pass. Useful for drawing pre-recorded pictures that don't require rendering into a separate subpass.

Definition at line 224 of file entity_pass.cc.

                                                                {
  if (!pass) {
    return;
  }
  FML_DCHECK(pass->superpass_ == nullptr);
 
  std::vector<Element>& elements = pass->elements_;
  for (auto i = 0u; i < elements.size(); i++) {
    elements_.emplace_back(std::move(elements[i]));
  }
 
  backdrop_filter_reads_from_pass_texture_ +=
      pass->backdrop_filter_reads_from_pass_texture_;
  advanced_blend_reads_from_pass_texture_ +=
      pass->advanced_blend_reads_from_pass_texture_;
}

Referenced by impeller::Canvas::DrawPicture().

Clone()

std::unique_ptr< EntityPass > impeller::EntityPass::Clone

(

)

const

Definition at line 1080 of file entity_pass.cc.

                                                  {
  std::vector<Element> new_elements;
  new_elements.reserve(elements_.size());
 
  for (const auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      new_elements.push_back(entity->Clone());
      continue;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      new_elements.push_back(subpass->get()->Clone());
      continue;
    }
    FML_UNREACHABLE();
  }
 
  auto pass = std::make_unique<EntityPass>();
  pass->SetElements(std::move(new_elements));
  pass->backdrop_filter_reads_from_pass_texture_ =
      backdrop_filter_reads_from_pass_texture_;
  pass->advanced_blend_reads_from_pass_texture_ =
      advanced_blend_reads_from_pass_texture_;
  pass->backdrop_filter_proc_ = backdrop_filter_proc_;
  pass->blend_mode_ = blend_mode_;
  pass->delegate_ = delegate_;
  // Note: I tried also adding flood clip and bounds limit but one of the
  // two caused rendering in wonderous to break. It's 10:51 PM, and I'm
  // ready to move on.
  return pass;
}

GetBoundsLimit()

std::optional< Rect > impeller::EntityPass::GetBoundsLimit

(

)

const

Get the bounds limit, which is provided by the user when creating a SaveLayer.

Definition at line 66 of file entity_pass.cc.

                                                   {
  return bounds_limit_;
}

Referenced by impeller::OpacityPeepholePassDelegate::CanCollapseIntoParentPass().

GetClearColor()

std::optional< Color > impeller::EntityPass::GetClearColor

(

ISize

size = ISize::Infinite()

)

const

Return the premultiplied clear color of the pass entities, if any.

Definition at line 1132 of file entity_pass.cc.

                                                                    {
  if (backdrop_filter_proc_) {
    return std::nullopt;
  }
 
  std::optional<Color> result = std::nullopt;
  for (const Element& element : elements_) {
    auto [entity_color, blend_mode] =
        ElementAsBackgroundColor(element, target_size);
    if (!entity_color.has_value()) {
      break;
    }
    result = result.value_or(Color::BlackTransparent())
                 .Blend(entity_color.value(), blend_mode);
  }
  if (result.has_value()) {
    return result->Premultiply();
  }
  return result;
}

GetClearColorOrDefault()

Color impeller::EntityPass::GetClearColorOrDefault

(

ISize

size = ISize::Infinite()

)

const

Return the premultiplied clear color of the pass entities.

If the entity pass has no clear color, this will return transparent black.

Definition at line 1128 of file entity_pass.cc.

                                                         {
  return GetClearColor(size).value_or(Color::BlackTransparent());
}

GetClipDepth()

size_t impeller::EntityPass::GetClipDepth

(

)

Definition at line 1119 of file entity_pass.cc.

                                {
  return clip_depth_;
}

GetElementCount()

size_t impeller::EntityPass::GetElementCount

(

)

const

Return the number of elements on this pass.

Definition at line 1076 of file entity_pass.cc.

                                         {
  return elements_.size();
}

Referenced by impeller::OpacityPeepholePassDelegate::CanCollapseIntoParentPass().

GetElementsCoverage()

std::optional< Rect > impeller::EntityPass::GetElementsCoverage

(

std::optional< Rect >

coverage_limit

)

const

Definition at line 97 of file entity_pass.cc.

                                            {
  std::optional<Rect> accumulated_coverage;
  for (const auto& element : elements_) {
    std::optional<Rect> element_coverage;
 
    if (auto entity = std::get_if<Entity>(&element)) {
      element_coverage = entity->GetCoverage();
 
      // When the coverage limit is std::nullopt, that means there is no limit,
      // as opposed to empty coverage.
      if (element_coverage.has_value() && coverage_limit.has_value()) {
        const auto* filter = entity->GetContents()->AsFilter();
        if (!filter || filter->IsTranslationOnly()) {
          element_coverage =
              element_coverage->Intersection(coverage_limit.value());
        }
      }
    } else if (auto subpass_ptr =
                   std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      auto& subpass = *subpass_ptr->get();
 
      std::optional<Rect> unfiltered_coverage =
          GetSubpassCoverage(subpass, std::nullopt);
 
      // If the current pass elements have any coverage so far and there's a
      // backdrop filter, then incorporate the backdrop filter in the
      // pre-filtered coverage of the subpass.
      if (accumulated_coverage.has_value() && subpass.backdrop_filter_proc_) {
        std::shared_ptr<FilterContents> backdrop_filter =
            subpass.backdrop_filter_proc_(
                FilterInput::Make(accumulated_coverage.value()),
                subpass.transform_, Entity::RenderingMode::kSubpass);
        if (backdrop_filter) {
          auto backdrop_coverage = backdrop_filter->GetCoverage({});
          unfiltered_coverage =
              Rect::Union(unfiltered_coverage, backdrop_coverage);
        } else {
          VALIDATION_LOG << "The EntityPass backdrop filter proc didn't return "
                            "a valid filter.";
        }
      }
 
      if (!unfiltered_coverage.has_value()) {
        continue;
      }
 
      // Additionally, subpass textures may be passed through filters, which may
      // modify the coverage.
      //
      // Note that we currently only assume that ImageFilters (such as blurs and
      // matrix transforms) may modify coverage, although it's technically
      // possible ColorFilters to affect coverage as well. For example: A
      // ColorMatrixFilter could output a completely transparent result, and
      // we could potentially detect this case as zero coverage in the future.
      std::shared_ptr<FilterContents> image_filter =
          subpass.delegate_->WithImageFilter(*unfiltered_coverage,
                                             subpass.transform_);
      if (image_filter) {
        Entity subpass_entity;
        subpass_entity.SetTransform(subpass.transform_);
        element_coverage = image_filter->GetCoverage(subpass_entity);
      } else {
        element_coverage = unfiltered_coverage;
      }
 
      element_coverage = Rect::Intersection(element_coverage, coverage_limit);
    } else {
      FML_UNREACHABLE();
    }
 
    accumulated_coverage = Rect::Union(accumulated_coverage, element_coverage);
  }
  return accumulated_coverage;
}

References GetSubpassCoverage(), impeller::TRect< Scalar >::Intersection(), impeller::Entity::kSubpass, impeller::FilterInput::Make(), impeller::Entity::SetTransform(), impeller::TRect< Scalar >::Union(), and VALIDATION_LOG.

Referenced by GetSubpassCoverage(), and impeller::testing::TEST_P().

GetSubpassCoverage()

std::optional< Rect > impeller::EntityPass::GetSubpassCoverage	(	const EntityPass &	subpass,
		std::optional< Rect >	coverage_limit
	)		const

Computes the coverage of a given subpass. This is used to determine the texture size of a given subpass before it's rendered to and passed through the subpass ImageFilter, if any.

Parameters

[in]	subpass	The EntityPass for which to compute pre-filteredcoverage.
[in]	coverage_limit	Confines coverage to a specified area. This hint is used to trim coverage to the root framebuffer area. std::nullopt means there is no limit.

Returns

The screen space pixel area that the subpass contents will render into, prior to being transformed by the subpass ImageFilter, if any. std::nullopt means rendering the subpass will have no effect on the color attachment.

Definition at line 173 of file entity_pass.cc.

                                            {
  std::shared_ptr<FilterContents> image_filter =
      subpass.delegate_->WithImageFilter(Rect(), subpass.transform_);
 
  // If the subpass has an image filter, then its coverage space may deviate
  // from the parent pass and make intersecting with the pass coverage limit
  // unsafe.
  if (image_filter && coverage_limit.has_value()) {
    coverage_limit = image_filter->GetSourceCoverage(subpass.transform_,
                                                     coverage_limit.value());
  }
 
  auto entities_coverage = subpass.GetElementsCoverage(coverage_limit);
  // The entities don't cover anything. There is nothing to do.
  if (!entities_coverage.has_value()) {
    return std::nullopt;
  }
 
  if (!subpass.bounds_limit_.has_value()) {
    return entities_coverage;
  }
  auto user_bounds_coverage =
      subpass.bounds_limit_->TransformBounds(subpass.transform_);
  return entities_coverage->Intersection(user_bounds_coverage);
}

References GetElementsCoverage().

Referenced by GetElementsCoverage(), and impeller::testing::TEST_P().

GetSubpassesDepth()

size_t impeller::EntityPass::GetSubpassesDepth

(

)

const

Definition at line 86 of file entity_pass.cc.

                                           {
  size_t max_subpass_depth = 0u;
  for (const auto& element : elements_) {
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      max_subpass_depth =
          std::max(max_subpass_depth, subpass->get()->GetSubpassesDepth());
    }
  }
  return max_subpass_depth + 1u;
}

GetSuperpass()

EntityPass * impeller::EntityPass::GetSuperpass

(

)

const

Definition at line 201 of file entity_pass.cc.

                                           {
  return superpass_;
}

Referenced by impeller::Canvas::Restore().

IterateAllElements()

void impeller::EntityPass::IterateAllElements

(

const std::function< bool(Element &)> &

iterator

)

Iterate all elements (entities and subpasses) in this pass, recursively including elements of child passes. The iteration order is depth-first. Whenever a subpass elements is encountered, it's included in the stream before its children.

Definition at line 999 of file entity_pass.cc.

                                                 {
  if (!iterator) {
    return;
  }
 
  for (auto& element : elements_) {
    if (!iterator(element)) {
      return;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      subpass->get()->IterateAllElements(iterator);
    }
  }
}

IterateAllEntities() [1/2]

void impeller::EntityPass::IterateAllEntities

(

const std::function< bool(const Entity &)> &

iterator

)

const

Iterate all entities in this pass, recursively including entities of child passes. The iteration order is depth-first and does not allow modification of the entities.

Definition at line 1036 of file entity_pass.cc.

                                                            {
  if (!iterator) {
    return;
  }
 
  for (const auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      if (!iterator(*entity)) {
        return;
      }
      continue;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      const EntityPass* entity_pass = subpass->get();
      entity_pass->IterateAllEntities(iterator);
      continue;
    }
    FML_UNREACHABLE();
  }
}

References IterateAllEntities().

IterateAllEntities() [2/2]

void impeller::EntityPass::IterateAllEntities

(

const std::function< bool(Entity &)> &

iterator

)

Iterate all entities in this pass, recursively including entities of child passes. The iteration order is depth-first.

Definition at line 1015 of file entity_pass.cc.

                                                {
  if (!iterator) {
    return;
  }
 
  for (auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      if (!iterator(*entity)) {
        return;
      }
      continue;
    }
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      subpass->get()->IterateAllEntities(iterator);
      continue;
    }
    FML_UNREACHABLE();
  }
}

Referenced by IterateAllEntities(), and Render().

IterateUntilSubpass()

bool impeller::EntityPass::IterateUntilSubpass

(

const std::function< bool(Entity &)> &

iterator

)

Iterate entities in this pass up until the first subpass is found. This is useful for limiting look-ahead optimizations.

Returns

Returns whether a subpass was encountered.

Definition at line 1058 of file entity_pass.cc.

                                                {
  if (!iterator) {
    return true;
  }
 
  for (auto& element : elements_) {
    if (auto entity = std::get_if<Entity>(&element)) {
      if (!iterator(*entity)) {
        return false;
      }
      continue;
    }
    return true;
  }
  return false;
}

Referenced by impeller::OpacityPeepholePassDelegate::CanCollapseIntoParentPass().

Render()

bool impeller::EntityPass::Render	(	ContentContext &	renderer,
		const RenderTarget &	render_target
	)		const

Definition at line 304 of file entity_pass.cc.

                                                                 {
  auto capture =
      renderer.GetContext()->capture.GetDocument(kCaptureDocumentName);
 
  renderer.GetRenderTargetCache()->Start();
 
  auto root_render_target = render_target;
 
  if (root_render_target.GetColorAttachments().find(0u) ==
      root_render_target.GetColorAttachments().end()) {
    VALIDATION_LOG << "The root RenderTarget must have a color attachment.";
    return false;
  }
 
  capture.AddRect("Coverage",
                  Rect::MakeSize(root_render_target.GetRenderTargetSize()),
                  {.readonly = true});
 
  fml::ScopedCleanupClosure reset_state([&renderer]() {
    renderer.GetLazyGlyphAtlas()->ResetTextFrames();
    renderer.GetRenderTargetCache()->End();
  });
 
  IterateAllEntities([lazy_glyph_atlas =
                          renderer.GetLazyGlyphAtlas()](const Entity& entity) {
    if (const auto& contents = entity.GetContents()) {
      contents->PopulateGlyphAtlas(lazy_glyph_atlas, entity.DeriveTextScale());
    }
    return true;
  });
 
  ClipCoverageStack clip_coverage_stack = {ClipCoverageLayer{
      .coverage = Rect::MakeSize(root_render_target.GetRenderTargetSize()),
      .clip_depth = 0}};
 
  bool reads_from_onscreen_backdrop = GetTotalPassReads(renderer) > 0;
  // In this branch path, we need to render everything to an offscreen texture
  // and then blit the results onto the onscreen texture. If using this branch,
  // there's no need to set up a stencil attachment on the root render target.
  if (reads_from_onscreen_backdrop) {
    auto offscreen_target = CreateRenderTarget(
        renderer, root_render_target.GetRenderTargetSize(), true,
        GetClearColorOrDefault(render_target.GetRenderTargetSize()));
 
    if (!OnRender(renderer,  // renderer
                  capture,   // capture
                  offscreen_target.GetRenderTarget()
                      .GetRenderTargetSize(),  // root_pass_size
                  offscreen_target,            // pass_target
                  Point(),                     // global_pass_position
                  Point(),                     // local_pass_position
                  0,                           // pass_depth
                  clip_coverage_stack          // clip_coverage_stack
                  )) {
      // Validation error messages are triggered for all `OnRender()` failure
      // cases.
      return false;
    }
 
    auto command_buffer = renderer.GetContext()->CreateCommandBuffer();
    command_buffer->SetLabel("EntityPass Root Command Buffer");
 
    // If the context supports blitting, blit the offscreen texture to the
    // onscreen texture. Otherwise, draw it to the parent texture using a
    // pipeline (slower).
    if (renderer.GetContext()
            ->GetCapabilities()
            ->SupportsTextureToTextureBlits()) {
      auto blit_pass = command_buffer->CreateBlitPass();
      blit_pass->AddCopy(
          offscreen_target.GetRenderTarget().GetRenderTargetTexture(),
          root_render_target.GetRenderTargetTexture());
 
      if (!command_buffer->EncodeAndSubmit(
              blit_pass, renderer.GetContext()->GetResourceAllocator())) {
        VALIDATION_LOG << "Failed to encode root pass blit command.";
        return false;
      }
    } else {
      auto render_pass = command_buffer->CreateRenderPass(root_render_target);
      render_pass->SetLabel("EntityPass Root Render Pass");
 
      {
        auto size_rect = Rect::MakeSize(
            offscreen_target.GetRenderTarget().GetRenderTargetSize());
        auto contents = TextureContents::MakeRect(size_rect);
        contents->SetTexture(
            offscreen_target.GetRenderTarget().GetRenderTargetTexture());
        contents->SetSourceRect(size_rect);
        contents->SetLabel("Root pass blit");
 
        Entity entity;
        entity.SetContents(contents);
        entity.SetBlendMode(BlendMode::kSource);
 
        if (!entity.Render(renderer, *render_pass)) {
          VALIDATION_LOG << "Failed to render EntityPass root blit.";
          return false;
        }
      }
 
      if (!command_buffer->EncodeAndSubmit(render_pass)) {
        VALIDATION_LOG << "Failed to encode root pass command buffer.";
        return false;
      }
    }
 
    return true;
  }
 
  // If we make it this far, that means the context is capable of rendering
  // everything directly to the onscreen texture.
 
  // The safety check for fetching this color attachment is at the beginning of
  // this method.
  auto color0 = root_render_target.GetColorAttachments().find(0u)->second;
 
  // If a root stencil was provided by the caller, then verify that it has a
  // configuration which can be used to render this pass.
  auto stencil_attachment = root_render_target.GetStencilAttachment();
  if (stencil_attachment.has_value()) {
    auto stencil_texture = stencil_attachment->texture;
    if (!stencil_texture) {
      VALIDATION_LOG << "The root RenderTarget must have a stencil texture.";
      return false;
    }
 
    auto stencil_storage_mode =
        stencil_texture->GetTextureDescriptor().storage_mode;
    if (reads_from_onscreen_backdrop &&
        stencil_storage_mode == StorageMode::kDeviceTransient) {
      VALIDATION_LOG << "The given root RenderTarget stencil needs to be read, "
                        "but it's marked as transient.";
      return false;
    }
  }
  // Setup a new root stencil with an optimal configuration if one wasn't
  // provided by the caller.
  else {
    root_render_target.SetupStencilAttachment(
        *renderer.GetContext(), *renderer.GetRenderTargetCache(),
        color0.texture->GetSize(),
        renderer.GetContext()->GetCapabilities()->SupportsOffscreenMSAA(),
        "ImpellerOnscreen",
        GetDefaultStencilConfig(reads_from_onscreen_backdrop));
  }
 
  // Set up the clear color of the root pass.
  color0.clear_color =
      GetClearColorOrDefault(render_target.GetRenderTargetSize());
  root_render_target.SetColorAttachment(color0, 0);
 
  EntityPassTarget pass_target(
      root_render_target,
      renderer.GetDeviceCapabilities().SupportsReadFromResolve(),
      renderer.GetDeviceCapabilities().SupportsImplicitResolvingMSAA());
 
  return OnRender(                               //
      renderer,                                  // renderer
      capture,                                   // capture
      root_render_target.GetRenderTargetSize(),  // root_pass_size
      pass_target,                               // pass_target
      Point(),                                   // global_pass_position
      Point(),                                   // local_pass_position
      0,                                         // pass_depth
      clip_coverage_stack);                      // clip_coverage_stack
}

References impeller::ContentContext::GetContext(), impeller::ContentContext::GetLazyGlyphAtlas(), impeller::ContentContext::GetRenderTargetCache(), IterateAllEntities(), kCaptureDocumentName, impeller::TRect< Scalar >::MakeSize(), and VALIDATION_LOG.

Referenced by impeller::EntityPlayground::OpenPlaygroundHere().

SetBackdropFilter()

void impeller::EntityPass::SetBackdropFilter

(

BackdropFilterProc

proc

)

Definition at line 1153 of file entity_pass.cc.

                                                          {
  if (superpass_) {
    VALIDATION_LOG << "Backdrop filters cannot be set on EntityPasses that "
                      "have already been appended to another pass.";
  }
 
  backdrop_filter_proc_ = std::move(proc);
}

References VALIDATION_LOG.

SetBlendMode()

void impeller::EntityPass::SetBlendMode

(

BlendMode

blend_mode

)

Definition at line 1123 of file entity_pass.cc.

                                                  {
  blend_mode_ = blend_mode;
  flood_clip_ = Entity::IsBlendModeDestructive(blend_mode);
}

SetBoundsLimit()

void impeller::EntityPass::SetBoundsLimit

(

std::optional< Rect >

bounds_limit

)

Set the bounds limit, which is provided by the user when creating a SaveLayer. This is a hint that allows the user to communicate that it's OK to not render content outside of the bounds.

For consistency with Skia, we effectively treat this like a rectangle clip by forcing the subpass texture size to never exceed it.

Definition at line 62 of file entity_pass.cc.

                                                              {
  bounds_limit_ = bounds_limit;
}

SetClipDepth()

void impeller::EntityPass::SetClipDepth

(

size_t

clip_depth

)

Definition at line 1115 of file entity_pass.cc.

                                               {
  clip_depth_ = clip_depth;
}

SetDelegate()

void impeller::EntityPass::SetDelegate

(

std::shared_ptr< EntityPassDelegate >

delgate

)

Definition at line 55 of file entity_pass.cc.

                                                                       {
  if (!delegate) {
    return;
  }
  delegate_ = std::move(delegate);
}

SetElements()

void impeller::EntityPass::SetElements

(

std::vector< Element >

elements

)

Definition at line 82 of file entity_pass.cc.

                                                        {
  elements_ = std::move(elements);
}

SetEnableOffscreenCheckerboard()

void impeller::EntityPass::SetEnableOffscreenCheckerboard

(

bool

enabled

)

Definition at line 1162 of file entity_pass.cc.

                                                            {
  enable_offscreen_debug_checkerboard_ = enabled;
}

SetTransform()

void impeller::EntityPass::SetTransform

(

Matrix

transform

)

Definition at line 1111 of file entity_pass.cc.

                                              {
  transform_ = transform;
}

Member Data Documentation

kCaptureDocumentName

const std::string impeller::EntityPass::kCaptureDocumentName = "EntityPass"

static

Definition at line 38 of file entity_pass.h.

Referenced by Render().

---

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

• impeller/entity/entity_pass.h
• impeller/entity/entity_pass.cc