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	RecordClip (const ClipContents &clip_contents, Matrix transform, Point global_pass_position, uint32_t clip_depth, size_t clip_height_floor, bool is_aa)

ReplayResult &	GetLastReplayResult ()

ClipStateResult	RecordRestore (Point global_pass_position, size_t restore_height)

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 23 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,
               }},
           },
   });
 }

References impeller::ClipCoverageLayer::coverage.

◆ ~EntityPassClipStack()

impeller::EntityPassClipStack::~EntityPassClipStack ( )

default

Member Function Documentation

◆ 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;
 }

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

◆ GetClipCoverageLayers()

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

Definition at line 50 of file entity_pass_clip_stack.cc.

                                                  {
   return subpass_state_.back().clip_coverage;
 }

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

◆ GetLastReplayResult()

ReplayResult& impeller::EntityPassClipStack::GetLastReplayResult ( )

inline

Definition at line 61 of file entity_pass_clip_stack.h.

                                       {
     return GetCurrentSubpassState().rendered_clip_entities.back();
   }

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

◆ GetReplayEntities()

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

Definition at line 209 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 28 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 44 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 32 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().

◆ RecordClip()

EntityPassClipStack::ClipStateResult impeller::EntityPassClipStack::RecordClip	(	const ClipContents &	clip_contents,
		Matrix	transform,
		Point	global_pass_position,
		uint32_t	clip_depth,
		size_t	clip_height_floor,
		bool	is_aa
	)

Definition at line 100 of file entity_pass_clip_stack.cc.

                 {
   ClipStateResult result = {.should_render = false, .clip_did_change = false};
  
   std::optional<Rect> maybe_clip_coverage = CurrentClipCoverage();
   // Running this append op won't impact the clip buffer because the
   // whole screen is already being clipped, so skip it.
   if (!maybe_clip_coverage.has_value()) {
     return result;
   }
   auto current_clip_coverage = maybe_clip_coverage.value();
   // Entity transforms are relative to the current pass position, so we need
   // to check clip coverage in the same space.
   current_clip_coverage = current_clip_coverage.Shift(-global_pass_position);
  
   ClipCoverage clip_coverage =
       clip_contents.GetClipCoverage(current_clip_coverage);
   if (clip_coverage.coverage.has_value()) {
     clip_coverage.coverage =
         clip_coverage.coverage->Shift(global_pass_position);
   }
  
   SubpassState& subpass_state = GetCurrentSubpassState();
  
   // 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 the new clip coverage is bigger than the existing coverage for
   // intersect clips, we do not need to change the clip region.
   if (!clip_coverage.is_difference_or_non_square &&
       clip_coverage.coverage.has_value() &&
       clip_coverage.coverage.value().Contains(current_clip_coverage)) {
     subpass_state.clip_coverage.push_back(ClipCoverageLayer{
         .coverage = current_clip_coverage,       //
         .clip_height = previous_clip_height + 1  //
     });
  
     return result;
   }
  
   // If the clip is an axis aligned rect and either is_aa is false or
   // the clip is very nearly integral, then the depth write can be
   // skipped for intersect clips. Since we use 4x MSAA, anything within
   // < ~0.125 of an integral value in either axis can be treated as
   // approximately the same as an integral value.
   bool should_render = true;
   std::optional<Rect> coverage_value = clip_coverage.coverage;
   if (!clip_coverage.is_difference_or_non_square &&
       coverage_value.has_value()) {
     const Rect& coverage = coverage_value.value();
     constexpr Scalar threshold = 0.124;
     if (!is_aa ||
         (std::abs(std::round(coverage.GetLeft()) - coverage.GetLeft()) <=
              threshold &&
          std::abs(std::round(coverage.GetTop()) - coverage.GetTop()) <=
              threshold &&
          std::abs(std::round(coverage.GetRight()) - coverage.GetRight()) <=
              threshold &&
          std::abs(std::round(coverage.GetBottom()) - coverage.GetBottom()) <=
              threshold)) {
       coverage_value = Rect::Round(clip_coverage.coverage.value());
       should_render = false;
     }
   }
  
   subpass_state.clip_coverage.push_back(ClipCoverageLayer{
       .coverage = coverage_value,              //
       .clip_height = previous_clip_height + 1  //
  
   });
   result.clip_did_change = true;
   result.should_render = should_render;
  
   FML_DCHECK(subpass_state.clip_coverage.back().clip_height ==
              subpass_state.clip_coverage.front().clip_height +
                  subpass_state.clip_coverage.size() - 1);
  
   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(ReplayResult{
       .clip_contents = clip_contents,   //
       .transform = transform,           //
       .clip_coverage = coverage_value,  //
       .clip_depth = clip_depth          //
   });
   next_replay_index_++;
  
   return result;
 }

References impeller::EntityPassClipStack::ReplayResult::clip_contents, impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::ClipCoverage::coverage, impeller::ClipCoverageLayer::coverage, CurrentClipCoverage(), impeller::TRect< T >::GetBottom(), impeller::ClipContents::GetClipCoverage(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::ClipCoverage::is_difference_or_non_square, impeller::TRect< Scalar >::Round(), impeller::EntityPassClipStack::ClipStateResult::should_render, and transform.

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

◆ RecordRestore()

EntityPassClipStack::ClipStateResult impeller::EntityPassClipStack::RecordRestore	(	Point	global_pass_position,
		size_t	restore_height
	)

Definition at line 54 of file entity_pass_clip_stack.cc.

                            {
   ClipStateResult result = {.should_render = false, .clip_did_change = false};
   auto& subpass_state = GetCurrentSubpassState();
  
   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;
  
   if (subpass_state.clip_coverage.back().coverage.has_value()) {
     FML_DCHECK(next_replay_index_ <=
                subpass_state.rendered_clip_entities.size());
     // https://github.com/flutter/flutter/issues/162172
     // This code is slightly wrong and should be popping more than one clip
     // entry.
     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();
       }
     }
   }
   return result;
 }