impeller::ClipContents Class Reference

#include <clip_contents.h>

Public Member Functions
	ClipContents (Rect coverage_rect, bool is_axis_aligned_rect)
	~ClipContents ()
void	SetGeometry (GeometryResult geometry)
	Set the pre-tessellated clip geometry. More...
void	SetClipOperation (Entity::ClipOperation clip_op)
ClipCoverage	GetClipCoverage (const std::optional< Rect > &current_clip_coverage) const
	Given the current pass space bounding rectangle of the clip buffer, return the expected clip coverage after this draw call. This should only be implemented for contents that may write to the clip buffer. More...
bool	Render (const ContentContext &renderer, RenderPass &pass, uint32_t clip_depth) const

Detailed Description

Definition at line 29 of file clip_contents.h.

Constructor & Destructor Documentation

ClipContents()

impeller::ClipContents::ClipContents	(	Rect	coverage_rect,
		bool	is_axis_aligned_rect
	)

Definition at line 31 of file clip_contents.cc.

    : coverage_rect_(coverage_rect),
      is_axis_aligned_rect_(is_axis_aligned_rect) {}

~ClipContents()

impeller::ClipContents::~ClipContents ( )

default

Member Function Documentation

GetClipCoverage()

ClipCoverage impeller::ClipContents::GetClipCoverage

(

const std::optional< Rect > &

current_clip_coverage

)

const

Given the current pass space bounding rectangle of the clip buffer, return the expected clip coverage after this draw call. This should only be implemented for contents that may write to the clip buffer.

During rendering, coverage coordinates count pixels from the top left corner of the framebuffer.

Definition at line 45 of file clip_contents.cc.

                                                          {
  if (!current_clip_coverage.has_value()) {
    return ClipCoverage{.coverage = std::nullopt};
  }
  switch (clip_op_) {
    case Entity::ClipOperation::kDifference:
      // This can be optimized further by considering cases when the bounds of
      // the current stencil will shrink.
      return {
          .is_difference_or_non_square = true,  //
          .coverage = current_clip_coverage     //
      };
    case Entity::ClipOperation::kIntersect:
      if (coverage_rect_.IsEmpty() || !current_clip_coverage.has_value()) {
        return ClipCoverage{.coverage = std::nullopt};
      }
      return {
          .is_difference_or_non_square = !is_axis_aligned_rect_,            //
          .coverage = current_clip_coverage->Intersection(coverage_rect_),  //
      };
  }
  FML_UNREACHABLE();
}

References impeller::ClipCoverage::coverage, impeller::TRect< T >::IsEmpty(), impeller::Entity::kDifference, and impeller::Entity::kIntersect.

Referenced by impeller::EntityPassClipStack::RecordClip().

Render()

bool impeller::ClipContents::Render	(	const ContentContext &	renderer,
		RenderPass &	pass,
		uint32_t	clip_depth
	)		const

Stencil preparation draw.

Write depth.

Definition at line 70 of file clip_contents.cc.

                                                     {
  if (!clip_geometry_.vertex_buffer) {
    return true;
  }
 
  using VS = ClipPipeline::VertexShader;
 
  VS::FrameInfo info;
  info.depth = GetShaderClipDepth(clip_depth);
  info.mvp = clip_geometry_.transform;
 
  auto options = OptionsFromPass(pass);
  options.blend_mode = BlendMode::kDst;
  options.primitive_type = clip_geometry_.type;
 
  pass.SetVertexBuffer(clip_geometry_.vertex_buffer);
 
  // kNormal and kPreventOverdraw geometries can do a difference clip by writing
  // depth directly without stencil-and-cover.
  if ((clip_geometry_.mode == GeometryResult::Mode::kNormal ||
       clip_geometry_.mode == GeometryResult::Mode::kPreventOverdraw) &&
      clip_op_ == Entity::ClipOperation::kDifference) {
    options.depth_write_enabled = true;
    pass.SetPipeline(renderer.GetClipPipeline(options));
 
    VS::BindFrameInfo(pass,
                      renderer.GetTransientsDataBuffer().EmplaceUniform(info));
 
    return pass.Draw().ok();
  }
 
  /// Stencil preparation draw.
 
  pass.SetStencilReference(0);
 
  options.depth_write_enabled = false;
  switch (clip_geometry_.mode) {
    case GeometryResult::Mode::kNonZero:
      pass.SetCommandLabel("Clip stencil preparation (NonZero)");
      options.stencil_mode =
          ContentContextOptions::StencilMode::kStencilNonZeroFill;
      break;
    case GeometryResult::Mode::kEvenOdd:
      pass.SetCommandLabel("Clip stencil preparation (EvenOdd)");
      options.stencil_mode =
          ContentContextOptions::StencilMode::kStencilEvenOddFill;
      break;
    case GeometryResult::Mode::kNormal:
    case GeometryResult::Mode::kPreventOverdraw:
      pass.SetCommandLabel("Clip stencil preparation (Increment)");
      options.stencil_mode =
          ContentContextOptions::StencilMode::kStencilIncrementAll;
      break;
  }
  pass.SetPipeline(renderer.GetClipPipeline(options));
 
  VS::BindFrameInfo(pass,
                    renderer.GetTransientsDataBuffer().EmplaceUniform(info));
 
  if (!pass.Draw().ok()) {
    return false;
  }
 
  /// Write depth.
 
  options.depth_write_enabled = true;
  options.primitive_type = PrimitiveType::kTriangleStrip;
  Rect cover_area;
  switch (clip_op_) {
    case Entity::ClipOperation::kIntersect:
      pass.SetCommandLabel("Intersect Clip");
      options.stencil_mode =
          ContentContextOptions::StencilMode::kCoverCompareInverted;
      cover_area = Rect::MakeSize(pass.GetRenderTargetSize());
      break;
    case Entity::ClipOperation::kDifference:
      pass.SetCommandLabel("Difference Clip");
      options.stencil_mode = ContentContextOptions::StencilMode::kCoverCompare;
      cover_area = coverage_rect_;
      break;
  }
  auto points = cover_area.GetPoints();
  pass.SetVertexBuffer(
      CreateVertexBuffer(points, renderer.GetTransientsDataBuffer()));
 
  pass.SetPipeline(renderer.GetClipPipeline(options));
 
  info.mvp = pass.GetOrthographicTransform();
  VS::BindFrameInfo(pass,
                    renderer.GetTransientsDataBuffer().EmplaceUniform(info));
 
  return pass.Draw().ok();
}

References impeller::CreateVertexBuffer(), impeller::RenderPass::Draw(), impeller::HostBuffer::EmplaceUniform(), impeller::ContentContext::GetClipPipeline(), impeller::RenderPass::GetOrthographicTransform(), impeller::TRect< T >::GetPoints(), impeller::RenderPass::GetRenderTargetSize(), impeller::GetShaderClipDepth(), impeller::ContentContext::GetTransientsDataBuffer(), impeller::ContentContextOptions::kCoverCompare, impeller::ContentContextOptions::kCoverCompareInverted, impeller::Entity::kDifference, impeller::kDst, impeller::GeometryResult::kEvenOdd, impeller::Entity::kIntersect, impeller::GeometryResult::kNonZero, impeller::GeometryResult::kNormal, impeller::GeometryResult::kPreventOverdraw, impeller::ContentContextOptions::kStencilEvenOddFill, impeller::ContentContextOptions::kStencilIncrementAll, impeller::ContentContextOptions::kStencilNonZeroFill, impeller::kTriangleStrip, impeller::TRect< Scalar >::MakeSize(), impeller::GeometryResult::mode, impeller::OptionsFromPass(), points, impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetPipeline(), impeller::RenderPass::SetStencilReference(), impeller::RenderPass::SetVertexBuffer(), impeller::GeometryResult::transform, impeller::GeometryResult::type, and impeller::GeometryResult::vertex_buffer.

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

SetClipOperation()

void impeller::ClipContents::SetClipOperation

(

Entity::ClipOperation

clip_op

)

Definition at line 41 of file clip_contents.cc.

                                                               {
  clip_op_ = clip_op;
}

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

SetGeometry()

void impeller::ClipContents::SetGeometry

(

GeometryResult

geometry

)

Set the pre-tessellated clip geometry.

Definition at line 37 of file clip_contents.cc.

                                                           {
  clip_geometry_ = std::move(clip_geometry);
}

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

---

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

• impeller/entity/contents/clip_contents.h
• impeller/entity/contents/clip_contents.cc