impeller::OpacityPeepholePassDelegate Class Reference

#include <paint_pass_delegate.h>

Inheritance diagram for impeller::OpacityPeepholePassDelegate:

Public Member Functions
	OpacityPeepholePassDelegate (Paint paint)
	~OpacityPeepholePassDelegate () override
bool	CanElide () override
bool	CanCollapseIntoParentPass (EntityPass *entity_pass) override
	Whether or not this entity pass can be collapsed into the parent. If true, this method may modify the entities for the current pass.
std::shared_ptr< Contents >	CreateContentsForSubpassTarget (std::shared_ptr< Texture > target, const Matrix &effect_transform) override
std::shared_ptr< FilterContents >	WithImageFilter (const FilterInput::Variant &input, const Matrix &effect_transform) const override
Public Member Functions inherited from impeller::EntityPassDelegate
	EntityPassDelegate ()
virtual	~EntityPassDelegate ()

Additional Inherited Members
Static Public Member Functions inherited from impeller::EntityPassDelegate
static std::unique_ptr< EntityPassDelegate >	MakeDefault ()

Detailed Description

A delegate that attempts to forward opacity from a save layer to child contents.

Currently this has a hardcoded limit of 3 entities in a pass, and cannot forward to child subpass delegates.

Definition at line 52 of file paint_pass_delegate.h.

Constructor & Destructor Documentation

OpacityPeepholePassDelegate()

impeller::OpacityPeepholePassDelegate::OpacityPeepholePassDelegate ( Paint  paint )

explicit

OpacityPeepholePassDelegate

Definition at line 60 of file paint_pass_delegate.cc.

    : paint_(std::move(paint)) {}

~OpacityPeepholePassDelegate()

impeller::OpacityPeepholePassDelegate::~OpacityPeepholePassDelegate ( )

overridedefault

Member Function Documentation

CanCollapseIntoParentPass()

bool impeller::OpacityPeepholePassDelegate::CanCollapseIntoParentPass ( EntityPass *  entity_pass )

overridevirtual

Whether or not this entity pass can be collapsed into the parent. If true, this method may modify the entities for the current pass.

Implements impeller::EntityPassDelegate.

Definition at line 72 of file paint_pass_delegate.cc.

                             {
  // Passes with enforced bounds that clip the contents can not be safely
  // collapsed.
  if (entity_pass->GetBoundsLimitMightClipContent()) {
    return false;
  }
 
  // OpacityPeepholePassDelegate will only get used if the pass's blend mode is
  // SourceOver, so no need to check here.
  if (paint_.color.alpha <= 0.0 || paint_.color.alpha >= 1.0 ||
      paint_.image_filter || paint_.color_filter) {
    return false;
  }
 
  // Note: determing whether any coverage intersects has quadradic complexity in
  // the number of rectangles, and depending on whether or not we cache at
  // different levels of the entity tree may end up cubic. In the interest of
  // proving whether or not this optimization is valuable, we only consider very
  // simple peephole optimizations here - where there is a single drawing
  // command wrapped in save layer. This would indicate something like an
  // Opacity or FadeTransition wrapping a very simple widget, like in the
  // CupertinoPicker.
  if (entity_pass->GetElementCount() > 3) {
    // Single paint command with a save layer would be:
    // 1. clip
    // 2. draw command
    // 3. restore.
    return false;
  }
  bool all_can_accept = true;
  std::vector<Rect> all_coverages;
  auto had_subpass = entity_pass->IterateUntilSubpass(
      [&all_coverages, &all_can_accept](Entity& entity) {
        const auto& contents = entity.GetContents();
        if (!entity.CanInheritOpacity()) {
          all_can_accept = false;
          return false;
        }
        auto maybe_coverage = contents->GetCoverage(entity);
        if (maybe_coverage.has_value()) {
          auto coverage = maybe_coverage.value();
          for (const auto& cv : all_coverages) {
            if (cv.IntersectsWithRect(coverage)) {
              all_can_accept = false;
              return false;
            }
          }
          all_coverages.push_back(coverage);
        }
        return true;
      });
  if (had_subpass || !all_can_accept) {
    return false;
  }
  auto alpha = paint_.color.alpha;
  entity_pass->IterateUntilSubpass([&alpha](Entity& entity) {
    entity.SetInheritedOpacity(alpha);
    return true;
  });
  return true;
}

CanElide()

bool impeller::OpacityPeepholePassDelegate::CanElide ( )

overridevirtual

Implements impeller::EntityPassDelegate.

Definition at line 67 of file paint_pass_delegate.cc.

                                           {
  return paint_.blend_mode == BlendMode::kDestination;
}

CreateContentsForSubpassTarget()

std::shared_ptr< Contents > impeller::OpacityPeepholePassDelegate::CreateContentsForSubpassTarget ( std::shared_ptr< Texture >  target, const Matrix &  effect_transform  )

overridevirtual

Implements impeller::EntityPassDelegate.

Definition at line 137 of file paint_pass_delegate.cc.

                                    {
  auto contents = TextureContents::MakeRect(Rect::MakeSize(target->GetSize()));
  contents->SetLabel("Subpass");
  contents->SetTexture(target);
  contents->SetSourceRect(Rect::MakeSize(target->GetSize()));
  contents->SetOpacity(paint_.color.alpha);
  contents->SetDeferApplyingOpacity(true);
 
  return paint_.WithFiltersForSubpassTarget(std::move(contents),
                                            effect_transform);
}

WithImageFilter()

std::shared_ptr< FilterContents > impeller::OpacityPeepholePassDelegate::WithImageFilter ( const FilterInput::Variant &  input, const Matrix &  effect_transform  ) const

overridevirtual

Implements impeller::EntityPassDelegate.

Definition at line 152 of file paint_pass_delegate.cc.

                                          {
  return paint_.WithImageFilter(input, effect_transform,
                                Entity::RenderingMode::kSubpass);
}

---

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

• impeller/aiks/paint_pass_delegate.h
• impeller/aiks/paint_pass_delegate.cc