#include <dl_builder.h>

Inheritance diagram for flutter::DisplayListBuilder:

Public Member Functions
	DisplayListBuilder (bool prepare_rtree)

	DisplayListBuilder (const SkRect &cull_rect=kMaxCullRect, bool prepare_rtree=false)

	~DisplayListBuilder ()

SkISize	GetBaseLayerSize () const override

SkImageInfo	GetImageInfo () const override

void	Save () override

void	SaveLayer (const SkRect bounds, const DlPaint paint=nullptr, const DlImageFilter *backdrop=nullptr) override

void	Restore () override

int	GetSaveCount () const override

void	RestoreToCount (int restore_count) override

void	Translate (SkScalar tx, SkScalar ty) override

void	Scale (SkScalar sx, SkScalar sy) override

void	Rotate (SkScalar degrees) override

void	Skew (SkScalar sx, SkScalar sy) override

void	Transform2DAffine (SkScalar mxx, SkScalar mxy, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myt) override

void	TransformFullPerspective (SkScalar mxx, SkScalar mxy, SkScalar mxz, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myz, SkScalar myt, SkScalar mzx, SkScalar mzy, SkScalar mzz, SkScalar mzt, SkScalar mwx, SkScalar mwy, SkScalar mwz, SkScalar mwt) override

void	TransformReset () override

void	Transform (const SkMatrix *matrix) override

void	Transform (const SkM44 *matrix44) override

void	SetTransform (const SkMatrix *matrix) override

void	SetTransform (const SkM44 *matrix44) override

SkM44	GetTransformFullPerspective () const override

SkMatrix	GetTransform () const override

void	ClipRect (const SkRect &rect, ClipOp clip_op=ClipOp::kIntersect, bool is_aa=false) override

void	ClipRRect (const SkRRect &rrect, ClipOp clip_op=ClipOp::kIntersect, bool is_aa=false) override

void	ClipPath (const SkPath &path, ClipOp clip_op=ClipOp::kIntersect, bool is_aa=false) override

SkRect	GetDestinationClipBounds () const override

SkRect	GetLocalClipBounds () const override

bool	QuickReject (const SkRect &bounds) const override

void	DrawPaint (const DlPaint &paint) override

void	DrawColor (DlColor color, DlBlendMode mode) override

void	DrawLine (const SkPoint &p0, const SkPoint &p1, const DlPaint &paint) override

void	DrawRect (const SkRect &rect, const DlPaint &paint) override

void	DrawOval (const SkRect &bounds, const DlPaint &paint) override

void	DrawCircle (const SkPoint &center, SkScalar radius, const DlPaint &paint) override

void	DrawRRect (const SkRRect &rrect, const DlPaint &paint) override

void	DrawDRRect (const SkRRect &outer, const SkRRect &inner, const DlPaint &paint) override

void	DrawPath (const SkPath &path, const DlPaint &paint) override

void	DrawArc (const SkRect &bounds, SkScalar start, SkScalar sweep, bool useCenter, const DlPaint &paint) override

void	DrawPoints (PointMode mode, uint32_t count, const SkPoint pts[], const DlPaint &paint) override

void	DrawVertices (const DlVertices *vertices, DlBlendMode mode, const DlPaint &paint) override

void	DrawImage (const sk_sp< DlImage > &image, const SkPoint point, DlImageSampling sampling, const DlPaint *paint=nullptr) override

void	DrawImageRect (const sk_sp< DlImage > &image, const SkRect &src, const SkRect &dst, DlImageSampling sampling, const DlPaint *paint=nullptr, SrcRectConstraint constraint=SrcRectConstraint::kFast) override

void	DrawImageNine (const sk_sp< DlImage > &image, const SkIRect &center, const SkRect &dst, DlFilterMode filter, const DlPaint *paint=nullptr) override

void	DrawAtlas (const sk_sp< DlImage > &atlas, const SkRSXform xform[], const SkRect tex[], const DlColor colors[], int count, DlBlendMode mode, DlImageSampling sampling, const SkRect cullRect, const DlPaint paint=nullptr) override

void	DrawDisplayList (const sk_sp< DisplayList > display_list, SkScalar opacity=SK_Scalar1) override

void	DrawTextBlob (const sk_sp< SkTextBlob > &blob, SkScalar x, SkScalar y, const DlPaint &paint) override

void	drawTextFrame (const std::shared_ptr< impeller::TextFrame > &text_frame, SkScalar x, SkScalar y) override

void	DrawTextFrame (const std::shared_ptr< impeller::TextFrame > &text_frame, SkScalar x, SkScalar y, const DlPaint &paint) override

void	DrawShadow (const SkPath &path, const DlColor color, const SkScalar elevation, bool transparent_occluder, SkScalar dpr) override

void	Flush () override

sk_sp< DisplayList >	Build ()

virtual void	Transform (const SkMatrix *matrix)=0

virtual void	Transform (const SkM44 *matrix44)=0

void	Transform (const SkMatrix &matrix)

void	Transform (const SkM44 &matrix44)

virtual void	DrawVertices (const DlVertices *vertices, DlBlendMode mode, const DlPaint &paint)=0

void	DrawVertices (const std::shared_ptr< const DlVertices > &vertices, DlBlendMode mode, const DlPaint &paint)

virtual void	DrawImageRect (const sk_sp< DlImage > &image, const SkRect &src, const SkRect &dst, DlImageSampling sampling, const DlPaint *paint=nullptr, SrcRectConstraint constraint=SrcRectConstraint::kFast)=0

virtual void	DrawImageRect (const sk_sp< DlImage > &image, const SkIRect &src, const SkRect &dst, DlImageSampling sampling, const DlPaint *paint=nullptr, SrcRectConstraint constraint=SrcRectConstraint::kFast)

void	DrawImageRect (const sk_sp< DlImage > &image, const SkRect &dst, DlImageSampling sampling, const DlPaint *paint=nullptr, SrcRectConstraint constraint=SrcRectConstraint::kFast)

Public Member Functions inherited from flutter::DlCanvas
virtual	~DlCanvas ()=default

void	Transform (const SkMatrix &matrix)

void	Transform (const SkM44 &matrix44)

virtual void	SetTransform (const SkMatrix &matrix)

virtual void	SetTransform (const SkM44 &matrix44)

void	Clear (DlColor color)

void	DrawVertices (const std::shared_ptr< const DlVertices > &vertices, DlBlendMode mode, const DlPaint &paint)

void	DrawImageRect (const sk_sp< DlImage > &image, const SkRect &dst, DlImageSampling sampling, const DlPaint *paint=nullptr, SrcRectConstraint constraint=SrcRectConstraint::kFast)

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Attributes
static constexpr SkRect	kMaxCullRect

Static Public Attributes inherited from flutter::DlCanvas
static constexpr SkScalar	kShadowLightHeight = 600

static constexpr SkScalar	kShadowLightRadius = 800

Private Member Functions
void	setAntiAlias (bool aa) override

void	setInvertColors (bool invert) override

void	setStrokeCap (DlStrokeCap cap) override

void	setStrokeJoin (DlStrokeJoin join) override

void	setDrawStyle (DlDrawStyle style) override

void	setStrokeWidth (float width) override

void	setStrokeMiter (float limit) override

void	setColor (DlColor color) override

void	setBlendMode (DlBlendMode mode) override

void	setColorSource (const DlColorSource *source) override

void	setImageFilter (const DlImageFilter *filter) override

void	setColorFilter (const DlColorFilter *filter) override

void	setPathEffect (const DlPathEffect *effect) override

void	setMaskFilter (const DlMaskFilter *filter) override

void	save () override

void	saveLayer (const SkRect &bounds, const SaveLayerOptions options, const DlImageFilter *backdrop) override

void	restore () override

void	translate (SkScalar tx, SkScalar ty) override

void	scale (SkScalar sx, SkScalar sy) override

void	rotate (SkScalar degrees) override

void	skew (SkScalar sx, SkScalar sy) override

void	transform2DAffine (SkScalar mxx, SkScalar mxy, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myt) override

void	transformFullPerspective (SkScalar mxx, SkScalar mxy, SkScalar mxz, SkScalar mxt, SkScalar myx, SkScalar myy, SkScalar myz, SkScalar myt, SkScalar mzx, SkScalar mzy, SkScalar mzz, SkScalar mzt, SkScalar mwx, SkScalar mwy, SkScalar mwz, SkScalar mwt) override

void	transformReset () override

void	clipRect (const SkRect &rect, ClipOp clip_op, bool is_aa) override

void	clipRRect (const SkRRect &rrect, ClipOp clip_op, bool is_aa) override

void	clipPath (const SkPath &path, ClipOp clip_op, bool is_aa) override

void	drawPaint () override

void	drawColor (DlColor color, DlBlendMode mode) override

void	drawLine (const SkPoint &p0, const SkPoint &p1) override

void	drawRect (const SkRect &rect) override

void	drawOval (const SkRect &bounds) override

void	drawCircle (const SkPoint &center, SkScalar radius) override

void	drawRRect (const SkRRect &rrect) override

void	drawDRRect (const SkRRect &outer, const SkRRect &inner) override

void	drawPath (const SkPath &path) override

void	drawArc (const SkRect &bounds, SkScalar start, SkScalar sweep, bool useCenter) override

void	drawPoints (PointMode mode, uint32_t count, const SkPoint pts[]) override

void	drawVertices (const DlVertices *vertices, DlBlendMode mode) override

void	drawImage (const sk_sp< DlImage > image, const SkPoint point, DlImageSampling sampling, bool render_with_attributes) override

void	drawImageRect (const sk_sp< DlImage > image, const SkRect &src, const SkRect &dst, DlImageSampling sampling, bool render_with_attributes, SrcRectConstraint constraint=SrcRectConstraint::kFast) override

void	drawImageNine (const sk_sp< DlImage > image, const SkIRect &center, const SkRect &dst, DlFilterMode filter, bool render_with_attributes) override

void	drawAtlas (const sk_sp< DlImage > atlas, const SkRSXform xform[], const SkRect tex[], const DlColor colors[], int count, DlBlendMode mode, DlImageSampling sampling, const SkRect *cullRect, bool render_with_attributes) override

void	drawDisplayList (const sk_sp< DisplayList > display_list, SkScalar opacity) override

void	drawTextBlob (const sk_sp< SkTextBlob > blob, SkScalar x, SkScalar y) override

void	drawShadow (const SkPath &path, const DlColor color, const SkScalar elevation, bool transparent_occluder, SkScalar dpr) override

Friends
DlOpReceiver &	DisplayListBuilderBenchmarkAccessor (DisplayListBuilder &builder)

DlOpReceiver &	DisplayListBuilderTestingAccessor (DisplayListBuilder &builder)

DlPaint	DisplayListBuilderTestingAttributes (DisplayListBuilder &builder)

Additional Inherited Members
Public Types inherited from flutter::DlCanvas
enum class	ClipOp { kDifference , kIntersect }

enum class	PointMode { kPoints , kLines , kPolygon }

enum class	SrcRectConstraint { kStrict , kFast }

Static Public Member Functions inherited from flutter::DlCanvas
static SkRect	ComputeShadowBounds (const SkPath &path, float elevation, SkScalar dpr, const SkMatrix &ctm)

Detailed Description

Definition at line 27 of file dl_builder.h.

Constructor & Destructor Documentation

◆ DisplayListBuilder() [1/2]

flutter::DisplayListBuilder::DisplayListBuilder ( bool prepare_rtree )

inlineexplicit

Definition at line 35 of file dl_builder.h.

36 : DisplayListBuilder(kMaxCullRect, prepare_rtree) {}

flutter::DisplayListBuilder::kMaxCullRect

static constexpr SkRect kMaxCullRect

Definition dl_builder.h:32

flutter::DisplayListBuilder::DisplayListBuilder

DisplayListBuilder(bool prepare_rtree)

Definition dl_builder.h:35

◆ DisplayListBuilder() [2/2]

flutter::DisplayListBuilder::DisplayListBuilder	(	const SkRect &	cull_rect = `kMaxCullRect`,
		bool	prepare_rtree = `false`
	)

explicit

Definition at line 102 of file dl_builder.cc.

    : tracker_(cull_rect, SkMatrix::I()) {
  if (prepare_rtree) {
    accumulator_ = std::make_unique<RTreeBoundsAccumulator>();
  } else {
    accumulator_ = std::make_unique<RectBoundsAccumulator>();
  }
 
  layer_stack_.emplace_back();
  current_layer_ = &layer_stack_.back();
}

◆ ~DisplayListBuilder()

flutter::DisplayListBuilder::~DisplayListBuilder ( )

Definition at line 115 of file dl_builder.cc.

                                        {
  uint8_t* ptr = storage_.get();
  if (ptr) {
    DisplayList::DisposeOps(ptr, ptr + used_);
  }
}

Member Function Documentation

◆ Build()

sk_sp< DisplayList > flutter::DisplayListBuilder::Build ( )

Definition at line 67 of file dl_builder.cc.

                                             {
  while (layer_stack_.size() > 1) {
    restore();
  }
 
  size_t bytes = used_;
  int count = render_op_count_;
  size_t nested_bytes = nested_bytes_;
  int nested_count = nested_op_count_;
  uint32_t total_depth = depth_;
  bool compatible = current_layer_->is_group_opacity_compatible();
  bool is_safe = is_ui_thread_safe_;
  bool affects_transparency = current_layer_->affects_transparent_layer();
 
  sk_sp<DlRTree> rtree = this->rtree();
  SkRect bounds = rtree ? rtree->bounds() : this->bounds();
 
  used_ = allocated_ = render_op_count_ = op_index_ = 0;
  nested_bytes_ = nested_op_count_ = 0;
  depth_ = 0;
  is_ui_thread_safe_ = true;
  storage_.realloc(bytes);
  layer_stack_.pop_back();
  layer_stack_.emplace_back();
  current_layer_ = &layer_stack_.back();
  tracker_.reset();
  layer_tracker_.reset();
  current_ = DlPaint();
 
  return sk_sp<DisplayList>(
      new DisplayList(std::move(storage_), bytes, count, nested_bytes,
                      nested_count, total_depth, bounds, compatible, is_safe,
                      affects_transparency, std::move(rtree)));
}

◆ clipPath()

void flutter::DisplayListBuilder::clipPath	(	const SkPath &	path,
		ClipOp	clip_op,
		bool	is_aa
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 404 of file dl_builder.h.

                                                                         {
    ClipPath(path, clip_op, is_aa);
  }

◆ ClipPath()

void flutter::DisplayListBuilder::ClipPath	(	const SkPath &	path,
		ClipOp	clip_op = `ClipOp::kIntersect`,
		bool	is_aa = `false`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 899 of file dl_builder.cc.

                                              {
  if (!path.isInverseFillType()) {
    SkRect rect;
    if (path.isRect(&rect)) {
      this->clipRect(rect, clip_op, is_aa);
      return;
    }
    SkRRect rrect;
    if (path.isOval(&rect)) {
      rrect.setOval(rect);
      this->clipRRect(rrect, clip_op, is_aa);
      return;
    }
    if (path.isRRect(&rrect)) {
      this->clipRRect(rrect, clip_op, is_aa);
      return;
    }
  }
  tracker_.clipPath(path, clip_op, is_aa);
  if (current_layer_->is_nop_ || tracker_.is_cull_rect_empty()) {
    current_layer_->is_nop_ = true;
    return;
  }
  checkForDeferredSave();
  switch (clip_op) {
    case ClipOp::kIntersect:
      Push<ClipIntersectPathOp>(0, path, is_aa);
      break;
    case ClipOp::kDifference:
      Push<ClipDifferencePathOp>(0, path, is_aa);
      break;
  }
}

◆ clipRect()

void flutter::DisplayListBuilder::clipRect	(	const SkRect &	rect,
		ClipOp	clip_op,
		bool	is_aa
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 396 of file dl_builder.h.

                                                                         {
    ClipRect(rect, clip_op, is_aa);
  }

◆ ClipRect()

void flutter::DisplayListBuilder::ClipRect	(	const SkRect &	rect,
		ClipOp	clip_op = `ClipOp::kIntersect`,
		bool	is_aa = `false`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 856 of file dl_builder.cc.

                                              {
  if (!rect.isFinite()) {
    return;
  }
  tracker_.clipRect(rect, clip_op, is_aa);
  if (current_layer_->is_nop_ || tracker_.is_cull_rect_empty()) {
    current_layer_->is_nop_ = true;
    return;
  }
  checkForDeferredSave();
  switch (clip_op) {
    case ClipOp::kIntersect:
      Push<ClipIntersectRectOp>(0, rect, is_aa);
      break;
    case ClipOp::kDifference:
      Push<ClipDifferenceRectOp>(0, rect, is_aa);
      break;
  }
}

◆ clipRRect()

void flutter::DisplayListBuilder::clipRRect	(	const SkRRect &	rrect,
		ClipOp	clip_op,
		bool	is_aa
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 400 of file dl_builder.h.

                                                                            {
    ClipRRect(rrect, clip_op, is_aa);
  }

◆ ClipRRect()

void flutter::DisplayListBuilder::ClipRRect	(	const SkRRect &	rrect,
		ClipOp	clip_op = `ClipOp::kIntersect`,
		bool	is_aa = `false`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 877 of file dl_builder.cc.

                                               {
  if (rrect.isRect()) {
    clipRect(rrect.rect(), clip_op, is_aa);
  } else {
    tracker_.clipRRect(rrect, clip_op, is_aa);
    if (current_layer_->is_nop_ || tracker_.is_cull_rect_empty()) {
      current_layer_->is_nop_ = true;
      return;
    }
    checkForDeferredSave();
    switch (clip_op) {
      case ClipOp::kIntersect:
        Push<ClipIntersectRRectOp>(0, rrect, is_aa);
        break;
      case ClipOp::kDifference:
        Push<ClipDifferenceRRectOp>(0, rrect, is_aa);
        break;
    }
  }
}

◆ drawArc()

void flutter::DisplayListBuilder::drawArc	(	const SkRect &	bounds,
		SkScalar	start,
		SkScalar	sweep,
		bool	useCenter
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1080 of file dl_builder.cc.

                                                 {
  DisplayListAttributeFlags flags =  //
      useCenter                      //
          ? kDrawArcWithCenterFlags
          : kDrawArcNoCenterFlags;
  OpResult result = PaintResult(current_, flags);
  // This could be tighter if we compute where the start and end
  // angles are and then also consider the quadrants swept and
  // the center if specified.
  if (result != OpResult::kNoEffect && AccumulateOpBounds(bounds, flags)) {
    Push<DrawArcOp>(0, bounds, start, sweep, useCenter);
    if (useCenter) {
      CheckLayerOpacityHairlineCompatibility();
    } else {
      CheckLayerOpacityCompatibility();
    }
    UpdateLayerResult(result);
  }
}

◆ DrawArc()

void flutter::DisplayListBuilder::DrawArc	(	const SkRect &	bounds,
		SkScalar	start,
		SkScalar	sweep,
		bool	useCenter,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1102 of file dl_builder.cc.

                                                       {
  SetAttributesFromPaint(
      paint, useCenter ? kDrawArcWithCenterFlags : kDrawArcNoCenterFlags);
  drawArc(bounds, start, sweep, useCenter);
}

◆ DrawAtlas()

void flutter::DisplayListBuilder::DrawAtlas	(	const sk_sp< DlImage > &	atlas,
		const SkRSXform	xform[],
		const SkRect	tex[],
		const DlColor	colors[],
		int	count,
		DlBlendMode	mode,
		DlImageSampling	sampling,
		const SkRect *	cullRect,
		const DlPaint *	paint = `nullptr`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1359 of file dl_builder.cc.

                                                         {
  if (paint != nullptr) {
    SetAttributesFromPaint(*paint,
                           DisplayListOpFlags::kDrawAtlasWithPaintFlags);
    drawAtlas(atlas, xform, tex, colors, count, mode, sampling, cull_rect,
              true);
  } else {
    drawAtlas(atlas, xform, tex, colors, count, mode, sampling, cull_rect,
              false);
  }
}

◆ drawAtlas()

void flutter::DisplayListBuilder::drawAtlas	(	const sk_sp< DlImage >	atlas,
		const SkRSXform	xform[],
		const SkRect	tex[],
		const DlColor	colors[],
		int	count,
		DlBlendMode	mode,
		DlImageSampling	sampling,
		const SkRect *	cullRect,
		bool	render_with_attributes
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1298 of file dl_builder.cc.

                                                                {
  DisplayListAttributeFlags flags = render_with_attributes  //
                                        ? kDrawAtlasWithPaintFlags
                                        : kDrawAtlasFlags;
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    return;
  }
  SkPoint quad[4];
  RectBoundsAccumulator atlasBounds;
  for (int i = 0; i < count; i++) {
    const SkRect& src = tex[i];
    xform[i].toQuad(src.width(), src.height(), quad);
    for (int j = 0; j < 4; j++) {
      atlasBounds.accumulate(quad[j]);
    }
  }
  if (atlasBounds.is_empty() ||
      !AccumulateOpBounds(atlasBounds.bounds(), flags)) {
    return;
  }
 
  int bytes = count * (sizeof(SkRSXform) + sizeof(SkRect));
  void* data_ptr;
  if (colors != nullptr) {
    bytes += count * sizeof(DlColor);
    if (cull_rect != nullptr) {
      data_ptr =
          Push<DrawAtlasCulledOp>(bytes, atlas, count, mode, sampling, true,
                                  *cull_rect, render_with_attributes);
    } else {
      data_ptr = Push<DrawAtlasOp>(bytes, atlas, count, mode, sampling, true,
                                   render_with_attributes);
    }
    CopyV(data_ptr, xform, count, tex, count, colors, count);
  } else {
    if (cull_rect != nullptr) {
      data_ptr =
          Push<DrawAtlasCulledOp>(bytes, atlas, count, mode, sampling, false,
                                  *cull_rect, render_with_attributes);
    } else {
      data_ptr = Push<DrawAtlasOp>(bytes, atlas, count, mode, sampling, false,
                                   render_with_attributes);
    }
    CopyV(data_ptr, xform, count, tex, count);
  }
  // drawAtlas treats each image as a separate operation so we cannot rely
  // on it to distribute the opacity without overlap without checking all
  // of the transforms and texture rectangles.
  UpdateLayerOpacityCompatibility(false);
  UpdateLayerResult(result);
  is_ui_thread_safe_ = is_ui_thread_safe_ && atlas->isUIThreadSafe();
}

◆ drawCircle()

void flutter::DisplayListBuilder::drawCircle	(	const SkPoint &	center,
		SkScalar	radius
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1005 of file dl_builder.cc.

                                                                          {
  DisplayListAttributeFlags flags = kDrawCircleFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect) {
    SkRect bounds = SkRect::MakeLTRB(center.fX - radius, center.fY - radius,
                                     center.fX + radius, center.fY + radius);
    if (AccumulateOpBounds(bounds, flags)) {
      Push<DrawCircleOp>(0, center, radius);
      CheckLayerOpacityCompatibility();
      UpdateLayerResult(result);
    }
  }
}

◆ DrawCircle()

void flutter::DisplayListBuilder::DrawCircle	(	const SkPoint &	center,
		SkScalar	radius,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1018 of file dl_builder.cc.

                                                          {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawCircleFlags);
  drawCircle(center, radius);
}

◆ DrawColor()

void flutter::DisplayListBuilder::DrawColor	(	DlColor	color,
		DlBlendMode	mode
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 951 of file dl_builder.cc.

                                                                  {
  OpResult result = PaintResult(DlPaint(color).setBlendMode(mode));
  if (result != OpResult::kNoEffect && AccumulateUnbounded()) {
    Push<DrawColorOp>(0, color, mode);
    CheckLayerOpacityCompatibility(mode);
    UpdateLayerResult(result);
  }
}

◆ drawColor()

void flutter::DisplayListBuilder::drawColor	(	DlColor	color,
		DlBlendMode	mode
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 411 of file dl_builder.h.

                                                           {
    DrawColor(color, mode);
  }

◆ drawDisplayList()

void flutter::DisplayListBuilder::drawDisplayList	(	const sk_sp< DisplayList >	display_list,
		SkScalar	opacity
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 469 of file dl_builder.h.

                                                  {
    DrawDisplayList(display_list, opacity);
  }

◆ DrawDisplayList()

void flutter::DisplayListBuilder::DrawDisplayList	(	const sk_sp< DisplayList >	display_list,
		SkScalar	opacity = `SK_Scalar1`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1379 of file dl_builder.cc.

                                                           {
  if (!std::isfinite(opacity) || opacity <= SK_ScalarNearlyZero ||
      display_list->op_count() == 0 || display_list->bounds().isEmpty() ||
      current_layer_->is_nop_) {
    return;
  }
  const SkRect bounds = display_list->bounds();
  bool accumulated;
  switch (accumulator()->type()) {
    case BoundsAccumulatorType::kRect:
      accumulated = AccumulateOpBounds(bounds, kDrawDisplayListFlags);
      break;
    case BoundsAccumulatorType::kRTree:
      auto rtree = display_list->rtree();
      if (rtree) {
        std::list<SkRect> rects =
            rtree->searchAndConsolidateRects(GetLocalClipBounds(), false);
        accumulated = false;
        for (const SkRect& rect : rects) {
          // TODO (https://github.com/flutter/flutter/issues/114919): Attributes
          // are not necessarily `kDrawDisplayListFlags`.
          if (AccumulateOpBounds(rect, kDrawDisplayListFlags)) {
            accumulated = true;
          }
        }
      } else {
        accumulated = AccumulateOpBounds(bounds, kDrawDisplayListFlags);
      }
      break;
  }
  if (!accumulated) {
    return;
  }
 
  DlPaint current_paint = current_;
  Push<DrawDisplayListOp>(0, display_list,
                          opacity < SK_Scalar1 ? opacity : SK_Scalar1);
 
  // This depth increment accounts for every draw call in the child
  // DisplayList and is in addition to the implicit depth increment
  // that was performed when we pushed the DrawDisplayListOp. The
  // eventual dispatcher can use or ignore the implicit depth increment
  // as it sees fit depending on whether it needs to do rendering
  // before or after the drawDisplayList op, but it must be accounted
  // for if the depth value accounting is to remain consistent between
  // the recording and dispatching process.
  depth_ += display_list->total_depth();
 
  is_ui_thread_safe_ = is_ui_thread_safe_ && display_list->isUIThreadSafe();
  // Not really necessary if the developer is interacting with us via
  // our attribute-state-less DlCanvas methods, but this avoids surprises
  // for those who may have been using the stateful Dispatcher methods.
  SetAttributesFromPaint(current_paint,
                         DisplayListOpFlags::kSaveLayerWithPaintFlags);
 
  // The non-nested op count accumulated in the |Push| method will include
  // this call to |drawDisplayList| for non-nested op count metrics.
  // But, for nested op count metrics we want the |drawDisplayList| call itself
  // to be transparent. So we subtract 1 from our accumulated nested count to
  // balance out against the 1 that was accumulated into the regular count.
  // This behavior is identical to the way SkPicture computed nested op counts.
  nested_op_count_ += display_list->op_count(true) - 1;
  nested_bytes_ += display_list->bytes(true);
  UpdateLayerOpacityCompatibility(display_list->can_apply_group_opacity());
  // Nop DisplayLists are eliminated above so we either affect transparent
  // pixels or we do not. We should not have [kNoEffect].
  UpdateLayerResult(display_list->modifies_transparent_black()
                        ? OpResult::kAffectsAll
                        : OpResult::kPreservesTransparency);
}

◆ drawDRRect()

void flutter::DisplayListBuilder::drawDRRect	(	const SkRRect &	outer,
		const SkRRect &	inner
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1044 of file dl_builder.cc.

                                                          {
  DisplayListAttributeFlags flags = kDrawDRRectFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect &&
      AccumulateOpBounds(outer.getBounds(), flags)) {
    Push<DrawDRRectOp>(0, outer, inner);
    CheckLayerOpacityCompatibility();
    UpdateLayerResult(result);
  }
}

◆ DrawDRRect()

void flutter::DisplayListBuilder::DrawDRRect	(	const SkRRect &	outer,
		const SkRRect &	inner,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1055 of file dl_builder.cc.

                                                          {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawDRRectFlags);
  drawDRRect(outer, inner);
}

◆ DrawImage()

void flutter::DisplayListBuilder::DrawImage	(	const sk_sp< DlImage > &	image,
		const SkPoint	point,
		DlImageSampling	sampling,
		const DlPaint *	paint = `nullptr`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1223 of file dl_builder.cc.

                                                         {
  if (paint != nullptr) {
    SetAttributesFromPaint(*paint,
                           DisplayListOpFlags::kDrawImageWithPaintFlags);
    drawImage(image, point, sampling, true);
  } else {
    drawImage(image, point, sampling, false);
  }
}

◆ drawImage()

void flutter::DisplayListBuilder::drawImage	(	const sk_sp< DlImage >	image,
		const SkPoint	point,
		DlImageSampling	sampling,
		bool	render_with_attributes
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1201 of file dl_builder.cc.

                                                                {
  DisplayListAttributeFlags flags = render_with_attributes  //
                                        ? kDrawImageWithPaintFlags
                                        : kDrawImageFlags;
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    return;
  }
  SkRect bounds = SkRect::MakeXYWH(point.fX, point.fY,  //
                                   image->width(), image->height());
  if (AccumulateOpBounds(bounds, flags)) {
    render_with_attributes
        ? Push<DrawImageWithAttrOp>(0, image, point, sampling)
        : Push<DrawImageOp>(0, image, point, sampling);
    CheckLayerOpacityCompatibility(render_with_attributes);
    UpdateLayerResult(result);
    is_ui_thread_safe_ = is_ui_thread_safe_ && image->isUIThreadSafe();
  }
}

◆ DrawImageNine()

void flutter::DisplayListBuilder::DrawImageNine	(	const sk_sp< DlImage > &	image,
		const SkIRect &	center,
		const SkRect &	dst,
		DlFilterMode	filter,
		const DlPaint *	paint = `nullptr`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1285 of file dl_builder.cc.

                                                             {
  if (paint != nullptr) {
    SetAttributesFromPaint(*paint,
                           DisplayListOpFlags::kDrawImageNineWithPaintFlags);
    drawImageNine(image, center, dst, filter, true);
  } else {
    drawImageNine(image, center, dst, filter, false);
  }
}

◆ drawImageNine()

void flutter::DisplayListBuilder::drawImageNine	(	const sk_sp< DlImage >	image,
		const SkIRect &	center,
		const SkRect &	dst,
		DlFilterMode	filter,
		bool	render_with_attributes
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1267 of file dl_builder.cc.

                                                                    {
  DisplayListAttributeFlags flags = render_with_attributes
                                        ? kDrawImageNineWithPaintFlags
                                        : kDrawImageNineFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect && AccumulateOpBounds(dst, flags)) {
    render_with_attributes
        ? Push<DrawImageNineWithAttrOp>(0, image, center, dst, filter)
        : Push<DrawImageNineOp>(0, image, center, dst, filter);
    CheckLayerOpacityCompatibility(render_with_attributes);
    UpdateLayerResult(result);
    is_ui_thread_safe_ = is_ui_thread_safe_ && image->isUIThreadSafe();
  }
}

◆ DrawImageRect() [1/4]

virtual void flutter::DlCanvas::DrawImageRect	(	const sk_sp< DlImage > &	image,
		const SkIRect &	src,
		const SkRect &	dst,
		DlImageSampling	sampling,
		const DlPaint *	paint = `nullptr`,
		SrcRectConstraint	constraint = `SrcRectConstraint::kFast`
	)

inlinevirtual

Reimplemented from flutter::DlCanvas.

Definition at line 173 of file dl_canvas.h.

                                                             {
    DrawImageRect(image, SkRect::Make(src), dst, sampling, paint, constraint);
  }

◆ DrawImageRect() [2/4]

void flutter::DlCanvas::DrawImageRect	(	const sk_sp< DlImage > &	image,
		const SkRect &	dst,
		DlImageSampling	sampling,
		const DlPaint *	paint = `nullptr`,
		SrcRectConstraint	constraint = `SrcRectConstraint::kFast`
	)

inline

Definition at line 182 of file dl_canvas.h.

                                                                            {
    DrawImageRect(image, image->bounds(), dst, sampling, paint, constraint);
  }

◆ DrawImageRect() [3/4]

void flutter::DisplayListBuilder::DrawImageRect	(	const sk_sp< DlImage > &	image,
		const SkRect &	src,
		const SkRect &	dst,
		DlImageSampling	sampling,
		const DlPaint *	paint = `nullptr`,
		SrcRectConstraint	constraint = `SrcRectConstraint::kFast`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1253 of file dl_builder.cc.

                                                                     {
  if (paint != nullptr) {
    SetAttributesFromPaint(*paint,
                           DisplayListOpFlags::kDrawImageRectWithPaintFlags);
    drawImageRect(image, src, dst, sampling, true, constraint);
  } else {
    drawImageRect(image, src, dst, sampling, false, constraint);
  }
}

◆ DrawImageRect() [4/4]

virtual void flutter::DlCanvas::DrawImageRect	(	const sk_sp< DlImage > &	image,
		const SkRect &	src,
		const SkRect &	dst,
		DlImageSampling	sampling,
		const DlPaint *	paint = `nullptr`,
		SrcRectConstraint	constraint = `SrcRectConstraint::kFast`
	)

virtual

Implements flutter::DlCanvas.

◆ drawImageRect()

void flutter::DisplayListBuilder::drawImageRect	(	const sk_sp< DlImage >	image,
		const SkRect &	src,
		const SkRect &	dst,
		DlImageSampling	sampling,
		bool	render_with_attributes,
		SrcRectConstraint	constraint = `SrcRectConstraint::kFast`
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1235 of file dl_builder.cc.

                                                                     {
  DisplayListAttributeFlags flags = render_with_attributes
                                        ? kDrawImageRectWithPaintFlags
                                        : kDrawImageRectFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect && AccumulateOpBounds(dst, flags)) {
    Push<DrawImageRectOp>(0, image, src, dst, sampling, render_with_attributes,
                          constraint);
    CheckLayerOpacityCompatibility(render_with_attributes);
    UpdateLayerResult(result);
    is_ui_thread_safe_ = is_ui_thread_safe_ && image->isUIThreadSafe();
  }
}

◆ drawLine()

void flutter::DisplayListBuilder::drawLine	(	const SkPoint &	p0,
		const SkPoint &	p1
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 959 of file dl_builder.cc.

                                                                      {
  SkRect bounds = SkRect::MakeLTRB(p0.fX, p0.fY, p1.fX, p1.fY).makeSorted();
  DisplayListAttributeFlags flags =
      (bounds.width() > 0.0f && bounds.height() > 0.0f) ? kDrawLineFlags
                                                        : kDrawHVLineFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect && AccumulateOpBounds(bounds, flags)) {
    Push<DrawLineOp>(0, p0, p1);
    CheckLayerOpacityCompatibility();
    UpdateLayerResult(result);
  }
}

◆ DrawLine()

void flutter::DisplayListBuilder::DrawLine	(	const SkPoint &	p0,
		const SkPoint &	p1,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 971 of file dl_builder.cc.

                                                        {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawLineFlags);
  drawLine(p0, p1);
}

◆ drawOval()

void flutter::DisplayListBuilder::drawOval ( const SkRect & bounds )

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 991 of file dl_builder.cc.

                                                      {
  DisplayListAttributeFlags flags = kDrawOvalFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect &&
      AccumulateOpBounds(bounds.makeSorted(), flags)) {
    Push<DrawOvalOp>(0, bounds);
    CheckLayerOpacityCompatibility();
    UpdateLayerResult(result);
  }
}

◆ DrawOval()

void flutter::DisplayListBuilder::DrawOval	(	const SkRect &	bounds,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1001 of file dl_builder.cc.

                                                                            {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawOvalFlags);
  drawOval(bounds);
}

◆ drawPaint()

void flutter::DisplayListBuilder::drawPaint ( )

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 939 of file dl_builder.cc.

                                   {
  OpResult result = PaintResult(current_, kDrawPaintFlags);
  if (result != OpResult::kNoEffect && AccumulateUnbounded()) {
    Push<DrawPaintOp>(0);
    CheckLayerOpacityCompatibility();
    UpdateLayerResult(result);
  }
}

◆ DrawPaint()

void flutter::DisplayListBuilder::DrawPaint ( const DlPaint & paint )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 947 of file dl_builder.cc.

                                                       {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawPaintFlags);
  drawPaint();
}

◆ drawPath()

void flutter::DisplayListBuilder::drawPath ( const SkPath & path )

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1061 of file dl_builder.cc.

                                                    {
  DisplayListAttributeFlags flags = kDrawPathFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect) {
    bool is_visible = path.isInverseFillType()
                          ? AccumulateUnbounded()
                          : AccumulateOpBounds(path.getBounds(), flags);
    if (is_visible) {
      Push<DrawPathOp>(0, path);
      CheckLayerOpacityHairlineCompatibility();
      UpdateLayerResult(result);
    }
  }
}

◆ DrawPath()

void flutter::DisplayListBuilder::DrawPath	(	const SkPath &	path,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1075 of file dl_builder.cc.

                                                                          {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawPathFlags);
  drawPath(path);
}

◆ drawPoints()

void flutter::DisplayListBuilder::drawPoints	(	PointMode	mode,
		uint32_t	count,
		const SkPoint	pts[]
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1124 of file dl_builder.cc.

                                                         {
  if (count == 0) {
    return;
  }
  DisplayListAttributeFlags flags = FlagsForPointMode(mode);
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    return;
  }
 
  FML_DCHECK(count < DlOpReceiver::kMaxDrawPointsCount);
  int bytes = count * sizeof(SkPoint);
  RectBoundsAccumulator ptBounds;
  for (size_t i = 0; i < count; i++) {
    ptBounds.accumulate(pts[i]);
  }
  SkRect point_bounds = ptBounds.bounds();
  if (!AccumulateOpBounds(point_bounds, flags)) {
    return;
  }
 
  void* data_ptr;
  switch (mode) {
    case PointMode::kPoints:
      data_ptr = Push<DrawPointsOp>(bytes, count);
      break;
    case PointMode::kLines:
      data_ptr = Push<DrawLinesOp>(bytes, count);
      break;
    case PointMode::kPolygon:
      data_ptr = Push<DrawPolygonOp>(bytes, count);
      break;
    default:
      FML_UNREACHABLE();
      return;
  }
  CopyV(data_ptr, pts, count);
  // drawPoints treats every point or line (or segment of a polygon)
  // as a completely separate operation meaning we cannot ensure
  // distribution of group opacity without analyzing the mode and the
  // bounds of every sub-primitive.
  // See: https://fiddle.skia.org/c/228459001d2de8db117ce25ef5cedb0c
  UpdateLayerOpacityCompatibility(false);
  UpdateLayerResult(result);
}

◆ DrawPoints()

void flutter::DisplayListBuilder::DrawPoints	(	PointMode	mode,
		uint32_t	count,
		const SkPoint	pts[],
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1171 of file dl_builder.cc.

                                                          {
  SetAttributesFromPaint(paint, FlagsForPointMode(mode));
  drawPoints(mode, count, pts);
}

◆ drawRect()

void flutter::DisplayListBuilder::drawRect ( const SkRect & rect )

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 977 of file dl_builder.cc.

                                                    {
  DisplayListAttributeFlags flags = kDrawRectFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect &&
      AccumulateOpBounds(rect.makeSorted(), flags)) {
    Push<DrawRectOp>(0, rect);
    CheckLayerOpacityCompatibility();
    UpdateLayerResult(result);
  }
}

◆ DrawRect()

void flutter::DisplayListBuilder::DrawRect	(	const SkRect &	rect,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 987 of file dl_builder.cc.

                                                                          {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawRectFlags);
  drawRect(rect);
}

◆ drawRRect()

void flutter::DisplayListBuilder::drawRRect ( const SkRRect & rrect )

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1024 of file dl_builder.cc.

                                                       {
  if (rrect.isRect()) {
    drawRect(rrect.rect());
  } else if (rrect.isOval()) {
    drawOval(rrect.rect());
  } else {
    DisplayListAttributeFlags flags = kDrawRRectFlags;
    OpResult result = PaintResult(current_, flags);
    if (result != OpResult::kNoEffect &&
        AccumulateOpBounds(rrect.getBounds(), flags)) {
      Push<DrawRRectOp>(0, rrect);
      CheckLayerOpacityCompatibility();
      UpdateLayerResult(result);
    }
  }
}

◆ DrawRRect()

void flutter::DisplayListBuilder::DrawRRect	(	const SkRRect &	rrect,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1040 of file dl_builder.cc.

                                                                             {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawRRectFlags);
  drawRRect(rrect);
}

◆ DrawShadow()

void flutter::DisplayListBuilder::DrawShadow	(	const SkPath &	path,
		const DlColor	color,
		const SkScalar	elevation,
		bool	transparent_occluder,
		SkScalar	dpr
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1526 of file dl_builder.cc.

                                                  {
  OpResult result = PaintResult(DlPaint(color));
  if (result != OpResult::kNoEffect) {
    SkRect shadow_bounds =
        DlCanvas::ComputeShadowBounds(path, elevation, dpr, GetTransform());
    if (AccumulateOpBounds(shadow_bounds, kDrawShadowFlags)) {
      transparent_occluder  //
          ? Push<DrawShadowTransparentOccluderOp>(0, path, color, elevation,
                                                  dpr)
          : Push<DrawShadowOp>(0, path, color, elevation, dpr);
      UpdateLayerOpacityCompatibility(false);
      UpdateLayerResult(result);
    }
  }
}

◆ drawShadow()

void flutter::DisplayListBuilder::drawShadow	(	const SkPath &	path,
		const DlColor	color,
		const SkScalar	elevation,
		bool	transparent_occluder,
		SkScalar	dpr
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 478 of file dl_builder.h.

                                         {
    DrawShadow(path, color, elevation, transparent_occluder, dpr);
  }

◆ DrawTextBlob()

void flutter::DisplayListBuilder::DrawTextBlob	(	const sk_sp< SkTextBlob > &	blob,
		SkScalar	x,
		SkScalar	y,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1477 of file dl_builder.cc.

                                                            {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawTextBlobFlags);
  drawTextBlob(blob, x, y);
}

◆ drawTextBlob()

void flutter::DisplayListBuilder::drawTextBlob	(	const sk_sp< SkTextBlob >	blob,
		SkScalar	x,
		SkScalar	y
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1450 of file dl_builder.cc.

                                                  {
  DisplayListAttributeFlags flags = kDrawTextBlobFlags;
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    return;
  }
  bool unclipped = AccumulateOpBounds(blob->bounds().makeOffset(x, y), flags);
  // TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
  // unit tests can use Fuchsia's font manager instead of the empty default.
  // Until then we might encounter empty bounds for otherwise valid text and
  // thus we ignore the results from AccumulateOpBounds.
#if defined(OS_FUCHSIA)
  unclipped = true;
#endif  // OS_FUCHSIA
  if (unclipped) {
    Push<DrawTextBlobOp>(0, blob, x, y);
    // There is no way to query if the glyphs of a text blob overlap and
    // there are no current guarantees from either Skia or Impeller that
    // they will protect overlapping glyphs from the effects of overdraw
    // so we must make the conservative assessment that this DL layer is
    // not compatible with group opacity inheritance.
    UpdateLayerOpacityCompatibility(false);
    UpdateLayerResult(result);
  }
}

◆ drawTextFrame()

void flutter::DisplayListBuilder::drawTextFrame	(	const std::shared_ptr< impeller::TextFrame > &	text_frame,
		SkScalar	x,
		SkScalar	y
	)

overridevirtual

Implements flutter::DlOpReceiver.

Definition at line 1485 of file dl_builder.cc.

                {
  DisplayListAttributeFlags flags = kDrawTextBlobFlags;
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    return;
  }
  impeller::Rect bounds = text_frame->GetBounds();
  SkRect sk_bounds = SkRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(),
                                      bounds.GetRight(), bounds.GetBottom());
  bool unclipped = AccumulateOpBounds(sk_bounds.makeOffset(x, y), flags);
  // TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
  // unit tests can use Fuchsia's font manager instead of the empty default.
  // Until then we might encounter empty bounds for otherwise valid text and
  // thus we ignore the results from AccumulateOpBounds.
#if defined(OS_FUCHSIA)
  unclipped = true;
#endif  // OS_FUCHSIA
  if (unclipped) {
    Push<DrawTextFrameOp>(0, text_frame, x, y);
    // There is no way to query if the glyphs of a text blob overlap and
    // there are no current guarantees from either Skia or Impeller that
    // they will protect overlapping glyphs from the effects of overdraw
    // so we must make the conservative assessment that this DL layer is
    // not compatible with group opacity inheritance.
    UpdateLayerOpacityCompatibility(false);
    UpdateLayerResult(result);
  }
}

◆ DrawTextFrame()

void flutter::DisplayListBuilder::DrawTextFrame	(	const std::shared_ptr< impeller::TextFrame > &	text_frame,
		SkScalar	x,
		SkScalar	y,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1517 of file dl_builder.cc.

                          {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawTextBlobFlags);
  drawTextFrame(text_frame, x, y);
}

◆ drawVertices()

void flutter::DisplayListBuilder::drawVertices	(	const DlVertices *	vertices,
		DlBlendMode	mode
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 1178 of file dl_builder.cc.

                                                        {
  DisplayListAttributeFlags flags = kDrawVerticesFlags;
  OpResult result = PaintResult(current_, flags);
  if (result != OpResult::kNoEffect &&
      AccumulateOpBounds(vertices->bounds(), flags)) {
    void* pod = Push<DrawVerticesOp>(vertices->size(), mode);
    new (pod) DlVertices(vertices);
    // DrawVertices applies its colors to the paint so we have no way
    // of controlling opacity using the current paint attributes.
    // Although, examination of the |mode| might find some predictable
    // cases.
    UpdateLayerOpacityCompatibility(false);
    UpdateLayerResult(result);
  }
}

◆ DrawVertices() [1/3]

void flutter::DisplayListBuilder::DrawVertices	(	const DlVertices *	vertices,
		DlBlendMode	mode,
		const DlPaint &	paint
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 1194 of file dl_builder.cc.

                                                            {
  SetAttributesFromPaint(paint, DisplayListOpFlags::kDrawVerticesFlags);
  drawVertices(vertices, mode);
}

◆ DrawVertices() [2/3]

virtual void flutter::DlCanvas::DrawVertices	(	const DlVertices *	vertices,
		DlBlendMode	mode,
		const DlPaint &	paint
	)

virtual

Implements flutter::DlCanvas.

◆ DrawVertices() [3/3]

void flutter::DlCanvas::DrawVertices	(	const std::shared_ptr< const DlVertices > &	vertices,
		DlBlendMode	mode,
		const DlPaint &	paint
	)

inline

Definition at line 157 of file dl_canvas.h.

                                          {
    DrawVertices(vertices.get(), mode, paint);
  }

◆ Flush()

void flutter::DisplayListBuilder::Flush ( )

inlineoverridevirtual

Implements flutter::DlCanvas.

Definition at line 245 of file dl_builder.h.

245{}

◆ GetBaseLayerSize()

SkISize flutter::DisplayListBuilder::GetBaseLayerSize ( ) const

overridevirtual

Implements flutter::DlCanvas.

Definition at line 122 of file dl_builder.cc.

                                                   {
  return tracker_.base_device_cull_rect().roundOut().size();
}

◆ GetDestinationClipBounds()

SkRect flutter::DisplayListBuilder::GetDestinationClipBounds ( ) const

inlineoverridevirtual

Conservative estimate of the bounds of all outstanding clip operations measured in the coordinate space within which this DisplayList will be rendered.

Implements flutter::DlCanvas.

Definition at line 132 of file dl_builder.h.

                                                   {
    return tracker_.device_cull_rect();
  }

◆ GetImageInfo()

SkImageInfo flutter::DisplayListBuilder::GetImageInfo ( ) const

overridevirtual

Implements flutter::DlCanvas.

Definition at line 126 of file dl_builder.cc.

                                                   {
  SkISize size = GetBaseLayerSize();
  return SkImageInfo::MakeUnknown(size.width(), size.height());
}

◆ GetLocalClipBounds()

SkRect flutter::DisplayListBuilder::GetLocalClipBounds ( ) const

inlineoverridevirtual

Conservative estimate of the bounds of all outstanding clip operations transformed into the local coordinate space in which currently recorded rendering operations are interpreted.

Implements flutter::DlCanvas.

Definition at line 139 of file dl_builder.h.

                                             {
    return tracker_.local_cull_rect();
  }

◆ GetSaveCount()

int flutter::DisplayListBuilder::GetSaveCount ( ) const

inlineoverridevirtual

Implements flutter::DlCanvas.

Definition at line 58 of file dl_builder.h.

58{ return layer_stack_.size(); }

◆ GetTransform()

SkMatrix flutter::DisplayListBuilder::GetTransform ( ) const

inlineoverridevirtual

Returns the 3x3 partial perspective transform representing all transform operations executed so far in this DisplayList within the enclosing save stack.

Implements flutter::DlCanvas.

Definition at line 113 of file dl_builder.h.

113{ return tracker_.matrix_3x3(); }

flutter::DisplayListMatrixClipTracker::matrix_3x3

SkMatrix matrix_3x3() const

Definition dl_matrix_clip_tracker.h:241

◆ GetTransformFullPerspective()

SkM44 flutter::DisplayListBuilder::GetTransformFullPerspective ( ) const

inlineoverridevirtual

Returns the 4x4 full perspective transform representing all transform operations executed so far in this DisplayList within the enclosing save stack.

Implements flutter::DlCanvas.

Definition at line 106 of file dl_builder.h.

                                                     {
    return tracker_.matrix_4x4();
  }

◆ QuickReject()

bool flutter::DisplayListBuilder::QuickReject ( const SkRect & bounds ) const

overridevirtual

Return true iff the supplied bounds are easily shown to be outside of the current clip bounds. This method may conservatively return false if it cannot make the determination.

Implements flutter::DlCanvas.

Definition at line 935 of file dl_builder.cc.

                                                               {
  return tracker_.content_culled(bounds);
}

◆ Restore()

void flutter::DisplayListBuilder::Restore ( )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 429 of file dl_builder.cc.

                                 {
  if (layer_stack_.size() <= 1) {
    return;
  }
 
  SaveOpBase* op = reinterpret_cast<SaveOpBase*>(storage_.get() +
                                                 current_layer_->save_offset());
 
  if (!current_layer_->has_deferred_save_op_) {
    op->restore_index = op_index_;
    op->total_content_depth = depth_ - current_layer_->start_depth_;
    Push<RestoreOp>(0);
    if (current_layer_->is_save_layer()) {
      // A saveLayer will usually do a final copy to the main buffer in
      // addition to its content, but that is accounted for outside of
      // the total content depth computed above.
      depth_ += render_op_depth_cost_;
    }
  }
 
  std::shared_ptr<const DlImageFilter> filter = current_layer_->filter();
  {
    // We should not pop the stack until we are done synching up the current
    // and parent layers.
    auto parent_layer = &layer_stack_.end()[-2];
 
    if (current_layer_->is_save_layer()) {
      // Layers are never deferred for now, we need to update the
      // following code if we ever do saveLayer culling...
      FML_DCHECK(!current_layer_->has_deferred_save_op_);
      FML_DCHECK(current_layer_->layer_accumulator_);
 
      SkRect content_bounds = current_layer_->layer_accumulator_->bounds();
 
      switch (op->type) {
        case DisplayListOpType::kSaveLayer:
        case DisplayListOpType::kSaveLayerBackdrop: {
          SaveLayerOpBase* layer_op = reinterpret_cast<SaveLayerOpBase*>(op);
          if (op->options.bounds_from_caller()) {
            if (!content_bounds.isEmpty() &&
                !layer_op->rect.contains(content_bounds)) {
              op->options = op->options.with_content_is_clipped();
              content_bounds.intersect(layer_op->rect);
            }
          }
          layer_op->rect = content_bounds;
          break;
        }
        default:
          FML_UNREACHABLE();
      }
 
      if (layer_tracker_->getSaveCount() > 1) {
        layer_tracker_->restore();
      } else {
        // If this was the last layer in the tracker, then there should
        // be no parent saveLayer.
        FML_DCHECK(!parent_layer->layer_accumulator_);
        layer_tracker_.reset();
      }
 
      if (parent_layer->layer_accumulator_) {
        SkRect bounds_for_parent = content_bounds;
        if (filter) {
          if (!filter->map_local_bounds(bounds_for_parent, bounds_for_parent)) {
            parent_layer->set_unbounded();
          }
        }
        // The content_bounds were accumulated in the base coordinate system
        // of the current layer, and have been adjusted there according to
        // its image filter.
        // The content bounds accumulation of the parent layer is relative
        // to the parent's base coordinate system, so we need to adjust
        // bounds_for_parent to that coordinate space.
        FML_DCHECK(layer_tracker_);
        layer_tracker_->mapRect(&bounds_for_parent);
        parent_layer->layer_accumulator_->accumulate(bounds_for_parent);
      }
 
      if (current_layer_->is_group_opacity_compatible()) {
        // We are now going to go back and modify the matching saveLayer
        // call to add the option indicating it can distribute an opacity
        // value to its children.
        //
        // Note that this operation cannot and does not change the size
        // or structure of the SaveLayerOp record. It only sets an option
        // flag on an existing field.
        //
        // Note that these kinds of modification operations on data already
        // in the DisplayList are only allowed *during* the build phase.
        // Once built, the DisplayList records must remain read only to
        // ensure consistency of rendering and |Equals()| behavior.
        op->options = op->options.with_can_distribute_opacity();
      }
    } else {
      if (layer_tracker_) {
        FML_DCHECK(layer_tracker_->getSaveCount() > 1);
        layer_tracker_->restore();
      }
      // For regular save() ops there was no protecting layer so we have to
      // accumulate the inheritance properties into the enclosing layer.
      if (current_layer_->cannot_inherit_opacity()) {
        parent_layer->mark_incompatible();
      } else if (current_layer_->has_compatible_op()) {
        parent_layer->add_compatible_op();
      }
    }
  }
 
  // Remember whether the outgoing layer was unbounded so we can adjust
  // for it below after we apply the outgoing layer's filter to the bounds.
  bool popped_was_unbounded = current_layer_->is_unbounded();
 
  // parent_layer is no longer in scope, time to pop the layer.
  layer_stack_.pop_back();
  tracker_.restore();
  current_layer_ = &layer_stack_.back();
 
  // As we pop the accumulator, use the filter that was applied to the
  // outgoing layer (saved above, if any) to adjust the bounds that
  // were accumulated while that layer was active.
  if (filter) {
    const SkRect clip = tracker_.device_cull_rect();
    if (!accumulator()->restore(
            [filter = filter, matrix = GetTransform()](const SkRect& input,
                                                       SkRect& output) {
              SkIRect output_bounds;
              bool ret = filter->map_device_bounds(input.roundOut(), matrix,
                                                   output_bounds);
              output.set(output_bounds);
              return ret;
            },
            &clip)) {
      popped_was_unbounded = true;
    }
  } else {
    accumulator()->restore();
  }
 
  if (popped_was_unbounded) {
    AccumulateUnbounded();
  }
}

◆ restore()

void flutter::DisplayListBuilder::restore ( )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 363 of file dl_builder.h.

363{ Restore(); }

flutter::DisplayListBuilder::Restore

void Restore() override

Definition dl_builder.cc:429

◆ RestoreToCount()

void flutter::DisplayListBuilder::RestoreToCount ( int restore_count )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 572 of file dl_builder.cc.

                                                         {
  FML_DCHECK(restore_count <= GetSaveCount());
  while (restore_count < GetSaveCount() && GetSaveCount() > 1) {
    restore();
  }
}

◆ Rotate()

void flutter::DisplayListBuilder::Rotate ( SkScalar degrees )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 729 of file dl_builder.cc.

                                                {
  if (SkScalarMod(degrees, 360.0) != 0.0) {
    checkForDeferredSave();
    Push<RotateOp>(0, degrees);
    tracker_.rotate(degrees);
    if (layer_tracker_) {
      layer_tracker_->rotate(degrees);
    }
  }
}

◆ rotate()

void flutter::DisplayListBuilder::rotate ( SkScalar degrees )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 370 of file dl_builder.h.

370{ Rotate(degrees); }

flutter::DisplayListBuilder::Rotate

void Rotate(SkScalar degrees) override

Definition dl_builder.cc:729

◆ Save()

void flutter::DisplayListBuilder::Save ( )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 400 of file dl_builder.cc.

                              {
  layer_stack_.emplace_back();
  current_layer_ = &layer_stack_.back();
 
  FML_DCHECK(layer_stack_.size() >= 2u);
  // Note we can't use the previous value of current_layer_ because
  // the emplace_back() may have moved the storage locations, so we
  // recompute the location of the penultimate layer info here.
  auto parent_layer = &layer_stack_.end()[-2];
 
  current_layer_->has_deferred_save_op_ = true;
  current_layer_->is_nop_ = parent_layer->is_nop_;
 
  if (parent_layer->layer_accumulator_) {
    FML_DCHECK(layer_tracker_);
    // If the previous layer was using an accumulator, we need to keep
    // filling it with content bounds. We reuse the previous accumulator
    // for this layer, but clone the associated transform so that new
    // transform mutations are restricted to this save/restore context.
    current_layer_->layer_accumulator_ = parent_layer->layer_accumulator_;
    layer_tracker_->save();
  } else {
    FML_DCHECK(!layer_tracker_);
  }
 
  tracker_.save();
  accumulator()->save();
}

◆ save()

void flutter::DisplayListBuilder::save ( )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 354 of file dl_builder.h.

354{ Save(); }

flutter::DisplayListBuilder::Save

void Save() override

Definition dl_builder.cc:400

◆ saveLayer()

void flutter::DisplayListBuilder::saveLayer	(	const SkRect &	bounds,
		const SaveLayerOptions	options,
		const DlImageFilter *	backdrop
	)

overrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 578 of file dl_builder.cc.

                                                                  {
  SaveLayerOptions options = in_options.without_optimizations();
  DisplayListAttributeFlags flags = options.renders_with_attributes()
                                        ? kSaveLayerWithPaintFlags
                                        : kSaveLayerFlags;
  OpResult result = PaintResult(current_, flags);
  if (result == OpResult::kNoEffect) {
    save();
    current_layer_->is_nop_ = true;
    return;
  }
 
  size_t save_layer_offset = used_;
 
  if (options.renders_with_attributes()) {
    // The actual flood of the outer layer clip will occur after the
    // (eventual) corresponding restore is called, but rather than
    // remember this information in the LayerInfo until the restore
    // method is processed, we just mark the unbounded state up front.
    // Another reason to accumulate the clip here rather than in
    // restore is so that this savelayer will be tagged in the rtree
    // with its full bounds and the right op_index so that it doesn't
    // get culled during rendering.
    if (!paint_nops_on_transparency()) {
      // We will fill the clip of the outer layer when we restore.
      // Accumulate should always return true here because if the
      // clip was empty then that would have been caught up above
      // when we tested the PaintResult.
      [[maybe_unused]] bool unclipped = AccumulateUnbounded();
      FML_DCHECK(unclipped);
    }
    CheckLayerOpacityCompatibility(true);
    layer_stack_.emplace_back(save_layer_offset, depth_);
    layer_stack_.back().filter_ = current_.getImageFilter();
  } else {
    CheckLayerOpacityCompatibility(false);
    layer_stack_.emplace_back(save_layer_offset, depth_);
  }
  current_layer_ = &layer_stack_.back();
  current_layer_->is_save_layer_ = true;
 
  tracker_.save();
  accumulator()->save();
 
  SkRect record_bounds;
  if (in_options.bounds_from_caller()) {
    options = options.with_bounds_from_caller();
    record_bounds = bounds;
  } else {
    FML_DCHECK(record_bounds.isEmpty());
  }
  current_layer_->layer_accumulator_.reset(new RectBoundsAccumulator());
  if (layer_tracker_) {
    layer_tracker_->save();
    layer_tracker_->setTransform(SkMatrix::I());
  } else {
    SkRect cull_rect;
    if (in_options.bounds_from_caller()) {
      cull_rect = bounds;
    } else {
      cull_rect = tracker_.local_cull_rect();
    }
    layer_tracker_.reset(
        new DisplayListMatrixClipTracker(cull_rect, SkMatrix::I()));
  }
 
  if (backdrop) {
    // A backdrop will affect up to the entire surface, bounded by the clip
    // Accumulate should always return true here because if the
    // clip was empty then that would have been caught up above
    // when we tested the PaintResult.
    [[maybe_unused]] bool unclipped = AccumulateUnbounded();
    FML_DCHECK(unclipped);
    Push<SaveLayerBackdropOp>(0, options, record_bounds, backdrop);
  } else {
    Push<SaveLayerOp>(0, options, record_bounds);
  }
 
  if (options.renders_with_attributes()) {
    // |current_opacity_compatibility_| does not take an ImageFilter into
    // account because an individual primitive with an ImageFilter can apply
    // opacity on top of it. But, if the layer is applying the ImageFilter
    // then it cannot pass the opacity on.
    if (!current_opacity_compatibility_ ||
        current_.getImageFilter() != nullptr) {
      UpdateLayerOpacityCompatibility(false);
    }
  }
  UpdateLayerResult(result);
 
  if (options.renders_with_attributes() && current_.getImageFilter()) {
    // We use |resetCullRect| here because we will be accumulating bounds of
    // primitives before applying the filter to those bounds. We might
    // encounter a primitive whose bounds are clipped, but whose filtered
    // bounds will not be clipped. If the individual rendering ops bounds
    // are clipped, it will not contribute to the overall bounds which
    // could lead to inaccurate (subset) bounds of the DisplayList.
    // We need to reset the cull rect here to avoid this premature clipping.
    // The filtered bounds will be clipped to the existing clip rect when
    // this layer is restored.
    // If bounds is null then the original cull_rect will be used.
    tracker_.resetLocalCullRect(in_options.bounds_from_caller() ? &bounds
                                                                : nullptr);
  } else if (in_options.bounds_from_caller()) {
    // Even though Skia claims that the bounds are only a hint, they actually
    // use them as the temporary layer bounds during rendering the layer, so
    // we set them as if a clip operation were performed.
    tracker_.clipRect(bounds, ClipOp::kIntersect, false);
  }
}

◆ SaveLayer()

void flutter::DisplayListBuilder::SaveLayer	(	const SkRect *	bounds,
		const DlPaint *	paint = `nullptr`,
		const DlImageFilter *	backdrop = `nullptr`
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 690 of file dl_builder.cc.

                                                                  {
  SaveLayerOptions options;
  SkRect temp_bounds;
  if (bounds) {
    options = options.with_bounds_from_caller();
    temp_bounds = *bounds;
  } else {
    temp_bounds.setEmpty();
  }
  if (paint != nullptr) {
    options = options.with_renders_with_attributes();
    SetAttributesFromPaint(*paint,
                           DisplayListOpFlags::kSaveLayerWithPaintFlags);
  }
  saveLayer(temp_bounds, options, backdrop);
}

◆ Scale()

void flutter::DisplayListBuilder::Scale	(	SkScalar	sx,
		SkScalar	sy
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 719 of file dl_builder.cc.

                                                       {
  if (std::isfinite(sx) && std::isfinite(sy) && (sx != 1.0 || sy != 1.0)) {
    checkForDeferredSave();
    Push<ScaleOp>(0, sx, sy);
    tracker_.scale(sx, sy);
    if (layer_tracker_) {
      layer_tracker_->scale(sx, sy);
    }
  }
}

◆ scale()

void flutter::DisplayListBuilder::scale	(	SkScalar	sx,
		SkScalar	sy
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 368 of file dl_builder.h.

368{ Scale(sx, sy); }

Scale

Definition dart.idl:629

◆ setAntiAlias()

void flutter::DisplayListBuilder::setAntiAlias ( bool aa )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 267 of file dl_builder.h.

                                      {
    if (current_.isAntiAlias() != aa) {
      onSetAntiAlias(aa);
    }
  }

◆ setBlendMode()

void flutter::DisplayListBuilder::setBlendMode ( DlBlendMode mode )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 315 of file dl_builder.h.

                                               {
    if (current_.getBlendMode() != mode) {
      onSetBlendMode(mode);
    }
  }

◆ setColor()

void flutter::DisplayListBuilder::setColor ( DlColor color )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 309 of file dl_builder.h.

                                        {
    if (current_.getColor() != color) {
      onSetColor(color);
    }
  }

◆ setColorFilter()

void flutter::DisplayListBuilder::setColorFilter ( const DlColorFilter * filter )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 333 of file dl_builder.h.

                                                            {
    if (NotEquals(current_.getColorFilter(), filter)) {
      onSetColorFilter(filter);
    }
  }

◆ setColorSource()

void flutter::DisplayListBuilder::setColorSource ( const DlColorSource * source )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 321 of file dl_builder.h.

                                                            {
    if (NotEquals(current_.getColorSource(), source)) {
      onSetColorSource(source);
    }
  }

◆ setDrawStyle()

void flutter::DisplayListBuilder::setDrawStyle ( DlDrawStyle style )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 291 of file dl_builder.h.

                                                {
    if (current_.getDrawStyle() != style) {
      onSetDrawStyle(style);
    }
  }

◆ setImageFilter()

void flutter::DisplayListBuilder::setImageFilter ( const DlImageFilter * filter )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 327 of file dl_builder.h.

                                                            {
    if (NotEquals(current_.getImageFilter(), filter)) {
      onSetImageFilter(filter);
    }
  }

◆ setInvertColors()

void flutter::DisplayListBuilder::setInvertColors ( bool invert )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 273 of file dl_builder.h.

                                             {
    if (current_.isInvertColors() != invert) {
      onSetInvertColors(invert);
    }
  }

◆ setMaskFilter()

void flutter::DisplayListBuilder::setMaskFilter ( const DlMaskFilter * filter )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 345 of file dl_builder.h.

                                                          {
    if (NotEquals(current_.getMaskFilter(), filter)) {
      onSetMaskFilter(filter);
    }
  }

◆ setPathEffect()

void flutter::DisplayListBuilder::setPathEffect ( const DlPathEffect * effect )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 339 of file dl_builder.h.

                                                          {
    if (NotEquals(current_.getPathEffect(), effect)) {
      onSetPathEffect(effect);
    }
  }

◆ setStrokeCap()

void flutter::DisplayListBuilder::setStrokeCap ( DlStrokeCap cap )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 279 of file dl_builder.h.

                                              {
    if (current_.getStrokeCap() != cap) {
      onSetStrokeCap(cap);
    }
  }

◆ setStrokeJoin()

void flutter::DisplayListBuilder::setStrokeJoin ( DlStrokeJoin join )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 285 of file dl_builder.h.

                                                 {
    if (current_.getStrokeJoin() != join) {
      onSetStrokeJoin(join);
    }
  }

◆ setStrokeMiter()

void flutter::DisplayListBuilder::setStrokeMiter ( float limit )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 303 of file dl_builder.h.

                                            {
    if (current_.getStrokeMiter() != limit) {
      onSetStrokeMiter(limit);
    }
  }

◆ setStrokeWidth()

void flutter::DisplayListBuilder::setStrokeWidth ( float width )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 297 of file dl_builder.h.

                                            {
    if (current_.getStrokeWidth() != width) {
      onSetStrokeWidth(width);
    }
  }

◆ SetTransform() [1/2]

void flutter::DisplayListBuilder::SetTransform ( const SkM44 * matrix44 )

inlineoverridevirtual

Implements flutter::DlCanvas.

Definition at line 96 of file dl_builder.h.

                                                    {
    TransformReset();
    Transform(matrix44);
  }

◆ SetTransform() [2/2]

void flutter::DisplayListBuilder::SetTransform ( const SkMatrix * matrix )

inlineoverridevirtual

Implements flutter::DlCanvas.

Definition at line 91 of file dl_builder.h.

                                                     {
    TransformReset();
    Transform(matrix);
  }

◆ Skew()

void flutter::DisplayListBuilder::Skew	(	SkScalar	sx,
		SkScalar	sy
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 739 of file dl_builder.cc.

                                                      {
  if (std::isfinite(sx) && std::isfinite(sy) && (sx != 0.0 || sy != 0.0)) {
    checkForDeferredSave();
    Push<SkewOp>(0, sx, sy);
    tracker_.skew(sx, sy);
    if (layer_tracker_) {
      layer_tracker_->skew(sx, sy);
    }
  }
}

◆ skew()

void flutter::DisplayListBuilder::skew	(	SkScalar	sx,
		SkScalar	sy
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 372 of file dl_builder.h.

372{ Skew(sx, sy); }

flutter::DisplayListBuilder::Skew

void Skew(SkScalar sx, SkScalar sy) override

Definition dl_builder.cc:739

◆ Transform() [1/6]

void flutter::DlCanvas::Transform ( const SkM44 & matrix44 )

inline

Definition at line 89 of file dl_canvas.h.

89{ Transform(&matrix44); }

◆ Transform() [2/6]

void flutter::DisplayListBuilder::Transform ( const SkM44 * matrix44 )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 846 of file dl_builder.cc.

                                                   {
  if (m44 != nullptr) {
    transformFullPerspective(
        m44->rc(0, 0), m44->rc(0, 1), m44->rc(0, 2), m44->rc(0, 3),
        m44->rc(1, 0), m44->rc(1, 1), m44->rc(1, 2), m44->rc(1, 3),
        m44->rc(2, 0), m44->rc(2, 1), m44->rc(2, 2), m44->rc(2, 3),
        m44->rc(3, 0), m44->rc(3, 1), m44->rc(3, 2), m44->rc(3, 3));
  }
}

◆ Transform() [3/6]

virtual void flutter::DlCanvas::Transform ( const SkM44 * matrix44 )

virtual

Implements flutter::DlCanvas.

◆ Transform() [4/6]

void flutter::DlCanvas::Transform ( const SkMatrix & matrix )

inline

Definition at line 88 of file dl_canvas.h.

88{ Transform(&matrix); }

◆ Transform() [5/6]

void flutter::DisplayListBuilder::Transform ( const SkMatrix * matrix )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 841 of file dl_builder.cc.

                                                         {
  if (matrix != nullptr) {
    Transform(SkM44(*matrix));
  }
}

◆ Transform() [6/6]

virtual void flutter::DlCanvas::Transform ( const SkMatrix * matrix )

virtual

Implements flutter::DlCanvas.

◆ Transform2DAffine()

void flutter::DisplayListBuilder::Transform2DAffine	(	SkScalar	mxx,
		SkScalar	mxy,
		SkScalar	mxt,
		SkScalar	myx,
		SkScalar	myy,
		SkScalar	myt
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 753 of file dl_builder.cc.

                                              {
  if (std::isfinite(mxx) && std::isfinite(myx) &&
      std::isfinite(mxy) && std::isfinite(myy) &&
      std::isfinite(mxt) && std::isfinite(myt)) {
    if (mxx == 1 && mxy == 0 &&
        myx == 0 && myy == 1) {
      Translate(mxt, myt);
    } else {
      checkForDeferredSave();
      Push<Transform2DAffineOp>(0,
                                mxx, mxy, mxt,
                                myx, myy, myt);
      tracker_.transform2DAffine(mxx, mxy, mxt,
                                 myx, myy, myt);
      if (layer_tracker_) {
        layer_tracker_->transform2DAffine(mxx, mxy, mxt,
                                          myx, myy, myt);
      }
    }
  }
}

◆ transform2DAffine()

void flutter::DisplayListBuilder::transform2DAffine	(	SkScalar	mxx,
		SkScalar	mxy,
		SkScalar	mxt,
		SkScalar	myx,
		SkScalar	myy,
		SkScalar	myt
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 376 of file dl_builder.h.

                                                                            {
    Transform2DAffine(mxx, mxy, mxt, myx, myy, myt);
  }

◆ TransformFullPerspective()

void flutter::DisplayListBuilder::TransformFullPerspective	(	SkScalar	mxx,
		SkScalar	mxy,
		SkScalar	mxz,
		SkScalar	mxt,
		SkScalar	myx,
		SkScalar	myy,
		SkScalar	myz,
		SkScalar	myt,
		SkScalar	mzx,
		SkScalar	mzy,
		SkScalar	mzz,
		SkScalar	mzt,
		SkScalar	mwx,
		SkScalar	mwy,
		SkScalar	mwz,
		SkScalar	mwt
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 777 of file dl_builder.cc.

                                                            {
  if (                        mxz == 0 &&
                              myz == 0 &&
      mzx == 0 && mzy == 0 && mzz == 1 && mzt == 0 &&
      mwx == 0 && mwy == 0 && mwz == 0 && mwt == 1) {
    Transform2DAffine(mxx, mxy, mxt,
                      myx, myy, myt);
  } else if (std::isfinite(mxx) && std::isfinite(mxy) &&
             std::isfinite(mxz) && std::isfinite(mxt) &&
             std::isfinite(myx) && std::isfinite(myy) &&
             std::isfinite(myz) && std::isfinite(myt) &&
             std::isfinite(mzx) && std::isfinite(mzy) &&
             std::isfinite(mzz) && std::isfinite(mzt) &&
             std::isfinite(mwx) && std::isfinite(mwy) &&
             std::isfinite(mwz) && std::isfinite(mwt)) {
    checkForDeferredSave();
    Push<TransformFullPerspectiveOp>(0,
                                     mxx, mxy, mxz, mxt,
                                     myx, myy, myz, myt,
                                     mzx, mzy, mzz, mzt,
                                     mwx, mwy, mwz, mwt);
    tracker_.transformFullPerspective(mxx, mxy, mxz, mxt,
                                      myx, myy, myz, myt,
                                      mzx, mzy, mzz, mzt,
                                      mwx, mwy, mwz, mwt);
    if (layer_tracker_) {
      layer_tracker_->transformFullPerspective(mxx, mxy, mxz, mxt,
                                               myx, myy, myz, myt,
                                               mzx, mzy, mzz, mzt,
                                               mwx, mwy, mwz, mwt);
    }
  }
}

◆ transformFullPerspective()

void flutter::DisplayListBuilder::transformFullPerspective	(	SkScalar	mxx,
		SkScalar	mxy,
		SkScalar	mxz,
		SkScalar	mxt,
		SkScalar	myx,
		SkScalar	myy,
		SkScalar	myz,
		SkScalar	myt,
		SkScalar	mzx,
		SkScalar	mzy,
		SkScalar	mzz,
		SkScalar	mzt,
		SkScalar	mwx,
		SkScalar	mwy,
		SkScalar	mwz,
		SkScalar	mwt
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 381 of file dl_builder.h.

                                                                       {
    TransformFullPerspective(mxx, mxy, mxz, mxt,
                             myx, myy, myz, myt,
                             mzx, mzy, mzz, mzt,
                             mwx, mwy, mwz, mwt);
  }

◆ TransformReset()

void flutter::DisplayListBuilder::TransformReset ( )

overridevirtual

Implements flutter::DlCanvas.

Definition at line 815 of file dl_builder.cc.

                                        {
  checkForDeferredSave();
  Push<TransformResetOp>(0);
  if (layer_tracker_) {
    // The matrices in layer_tracker_ and tracker_ are similar, but
    // start at a different base transform. The tracker_ potentially
    // has some number of transform operations on it that prefix the
    // operations accumulated in layer_tracker_. So we can't set them both
    // to identity in parallel as they would no longer maintain their
    // relationship to each other.
    // Instead we reinterpret this operation as transforming by the
    // inverse of the current transform. Doing so to tracker_ sets it
    // to identity so we can avoid the math there, but we must do the
    // math the long way for layer_tracker_. This becomes:
    //   layer_tracker_.transform(tracker_.inverse());
    if (!layer_tracker_->inverseTransform(tracker_)) {
      // If the inverse operation failed then that means that either
      // the matrix above the current layer was singular, or the matrix
      // became singular while we were accumulating the current layer.
      // In either case, we should no longer be accumulating any
      // contents so we set the layer tracking transform to a singular one.
      layer_tracker_->setTransform(SkMatrix::Scale(0.0f, 0.0f));
    }
  }
  tracker_.setIdentity();
}

◆ transformReset()

void flutter::DisplayListBuilder::transformReset ( )

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 393 of file dl_builder.h.

393{ TransformReset(); }

◆ Translate()

void flutter::DisplayListBuilder::Translate	(	SkScalar	tx,
		SkScalar	ty
	)

overridevirtual

Implements flutter::DlCanvas.

Definition at line 709 of file dl_builder.cc.

                                                           {
  if (std::isfinite(tx) && std::isfinite(ty) && (tx != 0.0 || ty != 0.0)) {
    checkForDeferredSave();
    Push<TranslateOp>(0, tx, ty);
    tracker_.translate(tx, ty);
    if (layer_tracker_) {
      layer_tracker_->translate(tx, ty);
    }
  }
}

◆ translate()

void flutter::DisplayListBuilder::translate	(	SkScalar	tx,
		SkScalar	ty
	)

inlineoverrideprivatevirtual

Implements flutter::DlOpReceiver.

Definition at line 366 of file dl_builder.h.

366{ Translate(tx, ty); }

Friends And Related Symbol Documentation

◆ DisplayListBuilderBenchmarkAccessor

DlOpReceiver & DisplayListBuilderBenchmarkAccessor ( DisplayListBuilder & builder )

friend

Definition at line 10 of file dl_builder_benchmarks.cc.

                                                                               {
  return builder.asReceiver();
}

◆ DisplayListBuilderTestingAccessor

DlOpReceiver & DisplayListBuilderTestingAccessor ( DisplayListBuilder & builder )

friend

Definition at line 33 of file display_list_unittests.cc.

                                                                             {
  return builder.asReceiver();
}

◆ DisplayListBuilderTestingAttributes

DlPaint DisplayListBuilderTestingAttributes ( DisplayListBuilder & builder )

friend

Definition at line 37 of file display_list_unittests.cc.

                                                                         {
  return builder.CurrentAttributes();
}

Member Data Documentation

◆ kMaxCullRect

constexpr SkRect flutter::DisplayListBuilder::kMaxCullRect

staticconstexpr

Initial value:

=

SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F)

Definition at line 32 of file dl_builder.h.

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

display_list/dl_builder.h
display_list/dl_builder.cc

Public Member Functions

Static Public Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DisplayListBuilder() [1/2]

◆ DisplayListBuilder() [2/2]

◆ ~DisplayListBuilder()

Member Function Documentation

◆ Build()

◆ clipPath()

◆ ClipPath()

◆ clipRect()

◆ ClipRect()

◆ clipRRect()

◆ ClipRRect()

◆ drawArc()

◆ DrawArc()

◆ DrawAtlas()

◆ drawAtlas()

◆ drawCircle()

◆ DrawCircle()

◆ DrawColor()

◆ drawColor()

◆ drawDisplayList()

◆ DrawDisplayList()

◆ drawDRRect()

◆ DrawDRRect()

◆ DrawImage()

◆ drawImage()

◆ DrawImageNine()

◆ drawImageNine()

◆ DrawImageRect() [1/4]

◆ DrawImageRect() [2/4]

◆ DrawImageRect() [3/4]

◆ DrawImageRect() [4/4]

◆ drawImageRect()

◆ drawLine()

◆ DrawLine()

◆ drawOval()

◆ DrawOval()

◆ drawPaint()

◆ DrawPaint()

◆ drawPath()

◆ DrawPath()

◆ drawPoints()

◆ DrawPoints()

◆ drawRect()

◆ DrawRect()

◆ drawRRect()

◆ DrawRRect()

◆ DrawShadow()

◆ drawShadow()

◆ DrawTextBlob()

◆ drawTextBlob()

◆ drawTextFrame()

◆ DrawTextFrame()

◆ drawVertices()

◆ DrawVertices() [1/3]

◆ DrawVertices() [2/3]

◆ DrawVertices() [3/3]

◆ Flush()

◆ GetBaseLayerSize()

◆ GetDestinationClipBounds()

◆ GetImageInfo()

◆ GetLocalClipBounds()

◆ GetSaveCount()

◆ GetTransform()

◆ GetTransformFullPerspective()

◆ QuickReject()

◆ Restore()

◆ restore()

◆ RestoreToCount()

◆ Rotate()

◆ rotate()

◆ Save()

◆ save()

◆ saveLayer()