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.
	~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.
void	RecordEntity (const Entity &entity, Contents::ClipCoverage::Type type, std::optional< Rect > clip_coverage)
const std::vector< ReplayResult > &	GetReplayEntities () const
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 12 of file entity_pass_clip_stack.cc.

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

~EntityPassClipStack()

impeller::EntityPassClipStack::~EntityPassClipStack ( )

default

Member Function Documentation

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 52 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 op = 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;
      }
 
      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);
 
      if (!op.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;
      }
    } 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;
  }
 
#ifdef IMPELLER_ENABLE_CAPTURE
  {
    auto element_entity_coverage = entity.GetCoverage();
    if (element_entity_coverage.has_value()) {
      element_entity_coverage =
          element_entity_coverage->Shift(global_pass_position);
      entity.GetCapture().AddRect("Coverage", *element_entity_coverage,
                                  {.readonly = true});
    }
  }
#endif
 
  RecordEntity(entity, global_clip_coverage.type,
               subpass_state.clip_coverage.back().coverage);
 
  result.should_render = true;
  return result;
}

CurrentClipCoverage()

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

(

)

const

Definition at line 24 of file entity_pass_clip_stack.cc.

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

GetClipCoverageLayers()

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

(

)

const

Definition at line 48 of file entity_pass_clip_stack.cc.

                                                 {
  return subpass_state_.back().clip_coverage;
}

GetReplayEntities()

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

(

)

const

Definition at line 171 of file entity_pass_clip_stack.cc.

                                             {
  return subpass_state_.back().rendered_clip_entities;
}

HasCoverage()

bool impeller::EntityPassClipStack::HasCoverage

(

)

const

Definition at line 28 of file entity_pass_clip_stack.cc.

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

PopSubpass()

void impeller::EntityPassClipStack::PopSubpass

(

)

Definition at line 43 of file entity_pass_clip_stack.cc.

                                     {
  subpass_state_.pop_back();
}

PushSubpass()

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

Definition at line 32 of file entity_pass_clip_stack.cc.

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

RecordEntity()

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

Definition at line 146 of file entity_pass_clip_stack.cc.

                                                                        {
  auto& subpass_state = GetCurrentSubpassState();
  switch (type) {
    case Contents::ClipCoverage::Type::kNoChange:
      return;
    case Contents::ClipCoverage::Type::kAppend:
      subpass_state.rendered_clip_entities.push_back(
          {.entity = entity.Clone(), .clip_coverage = clip_coverage});
      break;
    case Contents::ClipCoverage::Type::kRestore:
      if (!subpass_state.rendered_clip_entities.empty()) {
        subpass_state.rendered_clip_entities.pop_back();
      }
      break;
  }
}

---

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