impeller::EntityPassClipStack Class Reference

A class that tracks all clips that have been recorded in the current entity pass stencil. More...

#include <entity_pass_clip_stack.h>

Classes
struct	ClipStateResult
struct	ReplayResult

Public Member Functions
	EntityPassClipStack (const Rect &initial_coverage_rect)
	Create a new [EntityPassClipStack] with an initialized coverage rect. More...
	~EntityPassClipStack ()=default
std::optional< Rect >	CurrentClipCoverage () const
void	PushSubpass (std::optional< Rect > subpass_coverage, size_t clip_height)
void	PopSubpass ()
bool	HasCoverage () const
ClipStateResult	ApplyClipState (Contents::ClipCoverage global_clip_coverage, Entity &entity, size_t clip_height_floor, Point global_pass_position)
	Applies the current clip state to an Entity. If the given Entity is a clip operation, then the clip state is updated accordingly. More...
void	RecordEntity (const Entity &entity, Contents::ClipCoverage::Type type, std::optional< Rect > clip_coverage)
const std::vector< ReplayResult > &	GetReplayEntities () const
void	ActivateClipReplay ()
const ReplayResult *	GetNextReplayResult (size_t current_clip_depth)
	Returns the next Entity that should be replayed. If there are no enities to replay, then nullptr is returned. More...
const std::vector< ClipCoverageLayer >	GetClipCoverageLayers () const

Detailed Description

A class that tracks all clips that have been recorded in the current entity pass stencil.

These clips are replayed when restoring the backdrop so that the stencil buffer is left in an identical state.

Definition at line 24 of file entity_pass_clip_stack.h.

Constructor & Destructor Documentation

EntityPassClipStack()

impeller::EntityPassClipStack::EntityPassClipStack ( const Rect &  initial_coverage_rect )

explicit

Create a new [EntityPassClipStack] with an initialized coverage rect.

Definition at line 13 of file entity_pass_clip_stack.cc.

                                                                          {
  subpass_state_.push_back(SubpassState{
      .clip_coverage =
          {
              {ClipCoverageLayer{
                  .coverage = initial_coverage_rect,
                  .clip_height = 0,
              }},
          },
  });
}

References impeller::ClipCoverageLayer::coverage.

~EntityPassClipStack()

impeller::EntityPassClipStack::~EntityPassClipStack ( )

default

Member Function Documentation

ActivateClipReplay()

void impeller::EntityPassClipStack::ActivateClipReplay

(

)

Definition at line 189 of file entity_pass_clip_stack.cc.

                                             {
  next_replay_index_ = 0;
}

ApplyClipState()

EntityPassClipStack::ClipStateResult impeller::EntityPassClipStack::ApplyClipState	(	Contents::ClipCoverage	global_clip_coverage,
		Entity &	entity,
		size_t	clip_height_floor,
		Point	global_pass_position
	)

Applies the current clip state to an Entity. If the given Entity is a clip operation, then the clip state is updated accordingly.

Definition at line 55 of file entity_pass_clip_stack.cc.

                                {
  ClipStateResult result = {.should_render = false, .clip_did_change = false};
 
  auto& subpass_state = GetCurrentSubpassState();
  switch (global_clip_coverage.type) {
    case Contents::ClipCoverage::Type::kNoChange:
      break;
    case Contents::ClipCoverage::Type::kAppend: {
      auto maybe_coverage = CurrentClipCoverage();
 
      // Compute the previous clip height.
      size_t previous_clip_height = 0;
      if (!subpass_state.clip_coverage.empty()) {
        previous_clip_height = subpass_state.clip_coverage.back().clip_height;
      } else {
        // If there is no clip coverage, then the previous clip height is the
        // clip height floor.
        previous_clip_height = clip_height_floor;
      }
 
      if (!maybe_coverage.has_value()) {
        // Running this append op won't impact the clip buffer because the
        // whole screen is already being clipped, so skip it.
        return result;
      }
      auto op = maybe_coverage.value();
 
      // If the new clip coverage is bigger than the existing coverage for
      // intersect clips, we do not need to change the clip region.
      if (!global_clip_coverage.is_difference_or_non_square &&
          global_clip_coverage.coverage.has_value() &&
          global_clip_coverage.coverage.value().Contains(op)) {
        subpass_state.clip_coverage.push_back(ClipCoverageLayer{
            .coverage = op, .clip_height = previous_clip_height + 1});
 
        return result;
      }
 
      subpass_state.clip_coverage.push_back(
          ClipCoverageLayer{.coverage = global_clip_coverage.coverage,
                            .clip_height = previous_clip_height + 1});
      result.clip_did_change = true;
 
      FML_DCHECK(subpass_state.clip_coverage.back().clip_height ==
                 subpass_state.clip_coverage.front().clip_height +
                     subpass_state.clip_coverage.size() - 1);
 
    } break;
    case Contents::ClipCoverage::Type::kRestore: {
      ClipRestoreContents* restore_contents =
          reinterpret_cast<ClipRestoreContents*>(entity.GetContents().get());
      size_t restore_height = restore_contents->GetRestoreHeight();
 
      if (subpass_state.clip_coverage.back().clip_height <= restore_height) {
        // Drop clip restores that will do nothing.
        return result;
      }
 
      auto restoration_index =
          restore_height - subpass_state.clip_coverage.front().clip_height;
      FML_DCHECK(restoration_index < subpass_state.clip_coverage.size());
 
      // We only need to restore the area that covers the coverage of the
      // clip rect at target height + 1.
      std::optional<Rect> restore_coverage =
          (restoration_index + 1 < subpass_state.clip_coverage.size())
              ? subpass_state.clip_coverage[restoration_index + 1].coverage
              : std::nullopt;
      if (restore_coverage.has_value()) {
        // Make the coverage rectangle relative to the current pass.
        restore_coverage = restore_coverage->Shift(-global_pass_position);
      }
      subpass_state.clip_coverage.resize(restoration_index + 1);
      result.clip_did_change = true;
 
      // Skip all clip restores when stencil-then-cover is enabled.
      if (subpass_state.clip_coverage.back().coverage.has_value()) {
        RecordEntity(entity, global_clip_coverage.type, Rect());
      }
      return result;
 
    } break;
  }
 
  RecordEntity(entity, global_clip_coverage.type,
               subpass_state.clip_coverage.back().coverage);
 
  result.should_render = true;
  return result;
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::ClipCoverageLayer::coverage, impeller::Contents::ClipCoverage::coverage, CurrentClipCoverage(), impeller::Entity::GetContents(), impeller::ClipRestoreContents::GetRestoreHeight(), impeller::Contents::ClipCoverage::is_difference_or_non_square, impeller::Contents::ClipCoverage::kAppend, impeller::Contents::ClipCoverage::kNoChange, impeller::Contents::ClipCoverage::kRestore, RecordEntity(), impeller::EntityPassClipStack::ClipStateResult::should_render, and impeller::Contents::ClipCoverage::type.

Referenced by impeller::Canvas::Restore(), and impeller::testing::TEST().

CurrentClipCoverage()

std::optional< Rect > impeller::EntityPassClipStack::CurrentClipCoverage

(

)

const

Definition at line 25 of file entity_pass_clip_stack.cc.

                                                                 {
  return subpass_state_.back().clip_coverage.back().coverage;
}

Referenced by ApplyClipState(), impeller::Canvas::GetLocalCoverageLimit(), impeller::Canvas::Restore(), and impeller::testing::TEST().

GetClipCoverageLayers()

const std::vector< ClipCoverageLayer > impeller::EntityPassClipStack::GetClipCoverageLayers

(

)

const

Definition at line 51 of file entity_pass_clip_stack.cc.

                                                 {
  return subpass_state_.back().clip_coverage;
}

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

GetNextReplayResult()

const EntityPassClipStack::ReplayResult * impeller::EntityPassClipStack::GetNextReplayResult

(

size_t

current_clip_depth

)

Returns the next Entity that should be replayed. If there are no enities to replay, then nullptr is returned.

Definition at line 194 of file entity_pass_clip_stack.cc.

                                                                  {
  if (next_replay_index_ >=
      subpass_state_.back().rendered_clip_entities.size()) {
    // No clips need to be replayed.
    return nullptr;
  }
  ReplayResult* next_replay =
      &subpass_state_.back().rendered_clip_entities[next_replay_index_];
  if (next_replay->entity.GetClipDepth() < current_clip_depth) {
    // The next replay clip doesn't affect the current entity, so don't replay
    // it yet.
    return nullptr;
  }
 
  next_replay_index_++;
  return next_replay;
}

References impeller::EntityPassClipStack::ReplayResult::entity, and impeller::Entity::GetClipDepth().

GetReplayEntities()

const std::vector< EntityPassClipStack::ReplayResult > & impeller::EntityPassClipStack::GetReplayEntities

(

)

const

Definition at line 185 of file entity_pass_clip_stack.cc.

                                             {
  return subpass_state_.back().rendered_clip_entities;
}

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

HasCoverage()

bool impeller::EntityPassClipStack::HasCoverage

(

)

const

Definition at line 29 of file entity_pass_clip_stack.cc.

                                            {
  return !subpass_state_.back().clip_coverage.empty();
}

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

PopSubpass()

void impeller::EntityPassClipStack::PopSubpass

(

)

Definition at line 45 of file entity_pass_clip_stack.cc.

                                     {
  subpass_state_.pop_back();
  next_replay_index_ = subpass_state_.back().rendered_clip_entities.size();
}

Referenced by impeller::Canvas::Restore(), and impeller::testing::TEST().

PushSubpass()

void impeller::EntityPassClipStack::PushSubpass	(	std::optional< Rect >	subpass_coverage,
		size_t	clip_height
	)

Definition at line 33 of file entity_pass_clip_stack.cc.

                                                          {
  subpass_state_.push_back(SubpassState{
      .clip_coverage =
          {
              ClipCoverageLayer{.coverage = subpass_coverage,
                                .clip_height = clip_height},
          },
  });
  next_replay_index_ = 0;
}

References impeller::ClipCoverageLayer::coverage.

Referenced by impeller::Canvas::SaveLayer(), and impeller::testing::TEST().

RecordEntity()

void impeller::EntityPassClipStack::RecordEntity	(	const Entity &	entity,
		Contents::ClipCoverage::Type	type,
		std::optional< Rect >	clip_coverage
	)

Definition at line 150 of file entity_pass_clip_stack.cc.

                                                                        {
  auto& subpass_state = GetCurrentSubpassState();
  switch (type) {
    case Contents::ClipCoverage::Type::kNoChange:
      return;
    case Contents::ClipCoverage::Type::kAppend:
      FML_DCHECK(next_replay_index_ ==
                 subpass_state.rendered_clip_entities.size())
          << "Not all clips have been replayed before appending new clip.";
      subpass_state.rendered_clip_entities.push_back(
          {.entity = entity.Clone(), .clip_coverage = clip_coverage});
      next_replay_index_++;
      break;
    case Contents::ClipCoverage::Type::kRestore:
      FML_DCHECK(next_replay_index_ <=
                 subpass_state.rendered_clip_entities.size());
      if (!subpass_state.rendered_clip_entities.empty()) {
        subpass_state.rendered_clip_entities.pop_back();
 
        if (next_replay_index_ > subpass_state.rendered_clip_entities.size()) {
          next_replay_index_ = subpass_state.rendered_clip_entities.size();
        }
      }
      break;
  }
}

References impeller::Entity::Clone(), impeller::Contents::ClipCoverage::kAppend, impeller::Contents::ClipCoverage::kNoChange, impeller::Contents::ClipCoverage::kRestore, and type.

Referenced by ApplyClipState(), and impeller::testing::TEST().

---

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

• impeller/entity/entity_pass_clip_stack.h
• impeller/entity/entity_pass_clip_stack.cc