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

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 11 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

◆ 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 51 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;
   }
  
   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::kAppend, impeller::Contents::ClipCoverage::kNoChange, impeller::Contents::ClipCoverage::kRestore, RecordEntity(), impeller::EntityPassClipStack::ClipStateResult::should_render, and impeller::Contents::ClipCoverage::type.

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

◆ CurrentClipCoverage()

std::optional< Rect > impeller::EntityPassClipStack::CurrentClipCoverage ( ) const

Definition at line 23 of file entity_pass_clip_stack.cc.

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

Referenced by ApplyClipState(), impeller::ExperimentalCanvas::Restore(), and impeller::ExperimentalCanvas::SaveLayer().

◆ GetClipCoverageLayers()

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

Definition at line 47 of file entity_pass_clip_stack.cc.

                                                  {
   return subpass_state_.back().clip_coverage;
 }

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

◆ GetReplayEntities()

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

Definition at line 158 of file entity_pass_clip_stack.cc.

                                              {
   return subpass_state_.back().rendered_clip_entities;
 }

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

◆ HasCoverage()

bool impeller::EntityPassClipStack::HasCoverage ( ) const

Definition at line 27 of file entity_pass_clip_stack.cc.

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

Referenced by impeller::ExperimentalCanvas::SaveLayer().

◆ PopSubpass()

void impeller::EntityPassClipStack::PopSubpass ( )

Definition at line 42 of file entity_pass_clip_stack.cc.

                                      {
   subpass_state_.pop_back();
 }

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

◆ PushSubpass()

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

Definition at line 31 of file entity_pass_clip_stack.cc.

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

References impeller::ClipCoverageLayer::coverage.

Referenced by impeller::ExperimentalCanvas::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 133 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;
   }
 }

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

Classes

Public Member Functions