impeller::EntityPass Class Reference

#include <entity_pass.h>

Classes
struct	StencilCoverageLayer

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	StencilCoverageStack = std::vector< StencilCoverageLayer >

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)
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	SetTransformation (Matrix xformation)
void	SetStencilDepth (size_t stencil_depth)
size_t	GetStencilDepth ()
void	SetBlendMode (BlendMode blend_mode)
Color	GetClearColor (ISize size=ISize::Infinite()) const
void	SetBackdropFilter (BackdropFilterProc proc)
void	SetEnableOffscreenCheckerboard (bool enabled)
std::optional< Rect >	GetSubpassCoverage (const EntityPass &subpass, std::optional< Rect > coverage_limit) const
	Get the coverage of an unfiltered subpass. 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 26 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 44 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 37 of file entity_pass.h.

StencilCoverageStack

using impeller::EntityPass::StencilCoverageStack = std::vector<StencilCoverageLayer>

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

)

Definition at line 77 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::DrawImageRect(), 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 226 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 245 of file entity_pass.cc.

                                                                {
  if (!pass) {
    return;
  }
  FML_DCHECK(pass->superpass_ == nullptr);
 
  elements_.insert(elements_.end(),
                   std::make_move_iterator(pass->elements_.begin()),
                   std::make_move_iterator(pass->elements_.end()));
 
  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 1095 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);
      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 73 of file entity_pass.cc.

                                                   {
  return bounds_limit_;
}

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

GetClearColor()

Color impeller::EntityPass::GetClearColor

(

ISize

size = ISize::Infinite()

)

const

Definition at line 1143 of file entity_pass.cc.

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

References impeller::Color::Blend(), and impeller::Color::Premultiply().

GetElementCount()

size_t impeller::EntityPass::GetElementCount

(

)

const

Return the number of elements on this pass.

Definition at line 1091 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 104 of file entity_pass.cc.

                                            {
  std::optional<Rect> result;
  for (const auto& element : elements_) {
    std::optional<Rect> coverage;
 
    if (auto entity = std::get_if<Entity>(&element)) {
      coverage = entity->GetCoverage();
 
      // When the coverage limit is std::nullopt, that means there is no limit,
      // as opposed to empty coverage.
      if (coverage.has_value() && coverage_limit.has_value()) {
        const auto* filter = entity->GetContents()->AsFilter();
        if (!filter || filter->IsTranslationOnly()) {
          coverage = 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 (result.has_value() && subpass.backdrop_filter_proc_) {
        std::shared_ptr<FilterContents> backdrop_filter =
            subpass.backdrop_filter_proc_(FilterInput::Make(result.value()),
                                          subpass.xformation_,
                                          Entity::RenderingMode::kSubpass);
        if (backdrop_filter) {
          auto backdrop_coverage = backdrop_filter->GetCoverage({});
          backdrop_coverage->origin += result->origin;
          if (backdrop_coverage.has_value()) {
            if (unfiltered_coverage.has_value()) {
              unfiltered_coverage = coverage->Union(*backdrop_coverage);
            } else {
              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.xformation_);
      if (image_filter) {
        Entity subpass_entity;
        subpass_entity.SetTransformation(subpass.xformation_);
        coverage = image_filter->GetCoverage(subpass_entity);
      } else {
        coverage = unfiltered_coverage;
      }
 
      if (coverage.has_value() && coverage_limit.has_value() &&
          (!image_filter || image_filter->IsTranslationOnly())) {
        coverage = coverage->Intersection(coverage_limit.value());
      }
    } else {
      FML_UNREACHABLE();
    }
 
    if (!result.has_value() && coverage.has_value()) {
      result = coverage;
      continue;
    }
    if (!coverage.has_value()) {
      continue;
    }
    result = result->Union(coverage.value());
  }
  return result;
}

References GetSubpassCoverage(), impeller::Entity::kSubpass, impeller::FilterInput::Make(), impeller::Entity::SetTransformation(), and VALIDATION_LOG.

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

GetStencilDepth()

size_t impeller::EntityPass::GetStencilDepth

(

)

Definition at line 1134 of file entity_pass.cc.

                                   {
  return stencil_depth_;
}

GetSubpassCoverage()

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

Get the coverage of an unfiltered subpass.

Definition at line 195 of file entity_pass.cc.

                                            {
  std::shared_ptr<FilterContents> image_filter =
      subpass.delegate_->WithImageFilter(Rect(), subpass.xformation_);
 
  // If the filter graph transforms the basis of the subpass, then its space
  // has deviated too much from the parent pass to safely intersect with the
  // pass coverage limit.
  coverage_limit =
      (image_filter && !image_filter->IsTranslationOnly() ? std::nullopt
                                                          : coverage_limit);
 
  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.xformation_);
  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 93 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 222 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 1014 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 1051 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 1030 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 1073 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 323 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 (auto contents = entity.GetContents()) {
      contents->PopulateGlyphAtlas(lazy_glyph_atlas, entity.DeriveTextScale());
    }
    return true;
  });
 
  StencilCoverageStack stencil_coverage_stack = {StencilCoverageLayer{
      .coverage = Rect::MakeSize(root_render_target.GetRenderTargetSize()),
      .stencil_depth = 0}};
 
  bool supports_onscreen_backdrop_reads =
      renderer.GetDeviceCapabilities().SupportsReadFromOnscreenTexture() &&
      // If the backend doesn't have `SupportsReadFromResolve`, we need to flip
      // between two textures when restoring a previous MSAA pass.
      renderer.GetDeviceCapabilities().SupportsReadFromResolve();
  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 (!supports_onscreen_backdrop_reads && reads_from_onscreen_backdrop) {
    auto offscreen_target = CreateRenderTarget(
        renderer, root_render_target.GetRenderTargetSize(), true,
        GetClearColor(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
                  stencil_coverage_stack       // stencil_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 (!blit_pass->EncodeCommands(
              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);
 
        entity.Render(renderer, *render_pass);
      }
 
      if (!render_pass->EncodeCommands()) {
        VALIDATION_LOG << "Failed to encode root pass command buffer.";
        return false;
      }
    }
    if (!command_buffer->SubmitCommands()) {
      VALIDATION_LOG << "Failed to submit 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 = GetClearColor(render_target.GetRenderTargetSize());
  root_render_target.SetColorAttachment(color0, 0);
 
  EntityPassTarget pass_target(
      root_render_target,
      renderer.GetDeviceCapabilities().SupportsReadFromResolve());
 
  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
      stencil_coverage_stack);                   // stencil_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 1160 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 1138 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 69 of file entity_pass.cc.

                                                              {
  bounds_limit_ = bounds_limit;
}

SetDelegate()

void impeller::EntityPass::SetDelegate

(

std::shared_ptr< EntityPassDelegate >

delgate

)

Definition at line 62 of file entity_pass.cc.

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

SetElements()

void impeller::EntityPass::SetElements

(

std::vector< Element >

elements

)

Definition at line 89 of file entity_pass.cc.

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

SetEnableOffscreenCheckerboard()

void impeller::EntityPass::SetEnableOffscreenCheckerboard

(

bool

enabled

)

Definition at line 1169 of file entity_pass.cc.

                                                            {
  enable_offscreen_debug_checkerboard_ = enabled;
}

SetStencilDepth()

void impeller::EntityPass::SetStencilDepth

(

size_t

stencil_depth

)

Definition at line 1130 of file entity_pass.cc.

                                                     {
  stencil_depth_ = stencil_depth;
}

SetTransformation()

void impeller::EntityPass::SetTransformation

(

Matrix

xformation

)

Definition at line 1126 of file entity_pass.cc.

                                                    {
  xformation_ = xformation;
}

Member Data Documentation

kCaptureDocumentName

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

static

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