impeller::Canvas Class Reference

#include <canvas.h>

Classes
class	PathBlurShape
class	RRectBlurShape
class	RSuperellipseBlurShape
struct	SaveLayerState

Public Member Functions
	Canvas (ContentContext &renderer, const RenderTarget &render_target, bool is_onscreen, bool requires_readback)
	Canvas (ContentContext &renderer, const RenderTarget &render_target, bool is_onscreen, bool requires_readback, Rect cull_rect)
	Canvas (ContentContext &renderer, const RenderTarget &render_target, bool is_onscreen, bool requires_readback, IRect32 cull_rect)
	~Canvas ()=default
void	SetBackdropData (std::unordered_map< int64_t, BackdropData > backdrop_data, size_t backdrop_count)
	Update the backdrop data used to group together backdrop filters within the same layer.
std::optional< Rect >	GetLocalCoverageLimit () const
	Return the culling bounds of the current render target, or nullopt if there is no coverage.
void	Save (uint32_t total_content_depth=kMaxDepth)
void	SaveLayer (const Paint &paint, std::optional< Rect > bounds=std::nullopt, const flutter::DlImageFilter *backdrop_filter=nullptr, ContentBoundsPromise bounds_promise=ContentBoundsPromise::kUnknown, uint32_t total_content_depth=kMaxDepth, bool can_distribute_opacity=false, std::optional< int64_t > backdrop_id=std::nullopt)
bool	Restore ()
size_t	GetSaveCount () const
void	RestoreToCount (size_t count)
const Matrix &	GetCurrentTransform () const
void	ResetTransform ()
void	Transform (const Matrix &transform)
void	Concat (const Matrix &transform)
void	PreConcat (const Matrix &transform)
void	Translate (const Vector3 &offset)
void	Scale (const Vector2 &scale)
void	Scale (const Vector3 &scale)
void	Skew (Scalar sx, Scalar sy)
void	Rotate (Radians radians)
void	DrawPath (const flutter::DlPath &path, const Paint &paint)
void	DrawPaint (const Paint &paint)
void	DrawLine (const Point &p0, const Point &p1, const Paint &paint, bool reuse_depth=false)
void	DrawDashedLine (const Point &p0, const Point &p1, Scalar on_length, Scalar off_length, const Paint &paint)
void	DrawRect (const Rect &rect, const Paint &paint)
void	DrawOval (const Rect &rect, const Paint &paint)
void	DrawArc (const Arc &arc, const Paint &paint)
void	DrawRoundRect (const RoundRect &rect, const Paint &paint)
void	DrawDiffRoundRect (const RoundRect &outer, const RoundRect &inner, const Paint &paint)
void	DrawRoundSuperellipse (const RoundSuperellipse &rse, const Paint &paint)
void	DrawCircle (const Point &center, Scalar radius, const Paint &paint)
void	DrawPoints (const Point points[], uint32_t count, Scalar radius, const Paint &paint, PointStyle point_style)
void	DrawImage (const std::shared_ptr< Texture > &image, Point offset, const Paint &paint, const SamplerDescriptor &sampler={})
void	DrawImageRect (const std::shared_ptr< Texture > &image, Rect source, Rect dest, const Paint &paint, const SamplerDescriptor &sampler={}, SourceRectConstraint src_rect_constraint=SourceRectConstraint::kFast)
void	DrawTextFrame (const std::shared_ptr< TextFrame > &text_frame, Point position, const Paint &paint)
void	DrawVertices (const std::shared_ptr< VerticesGeometry > &vertices, BlendMode blend_mode, const Paint &paint)
void	DrawAtlas (const std::shared_ptr< AtlasContents > &atlas_contents, const Paint &paint)
void	ClipGeometry (const Geometry &geometry, Entity::ClipOperation clip_op, bool is_aa=true)
void	EndReplay ()
uint64_t	GetOpDepth () const
uint64_t	GetMaxOpDepth () const
bool	RequiresReadback () const
bool	SupportsBlitToOnscreen () const
bool	EnsureFinalMipmapGeneration () const

Static Public Member Functions
static bool	IsCompatibleWithSDFRendering (const Paint &paint)

Static Public Attributes
static constexpr uint32_t	kMaxDepth = 1 << 24

Detailed Description

Definition at line 119 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/3]

impeller::Canvas::Canvas	(	ContentContext &	renderer,
		const RenderTarget &	render_target,
		bool	is_onscreen,
		bool	requires_readback
	)

Definition at line 298 of file canvas.cc.

    : renderer_(renderer),
      render_target_(render_target),
      is_onscreen_(is_onscreen),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  Initialize(std::nullopt);
  SetupRenderPass();
}

Canvas() [2/3]

impeller::Canvas::Canvas ( ContentContext &  renderer, const RenderTarget &  render_target, bool  is_onscreen, bool  requires_readback, Rect  cull_rect  )

explicit

Definition at line 312 of file canvas.cc.

    : renderer_(renderer),
      render_target_(render_target),
      is_onscreen_(is_onscreen),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  Initialize(cull_rect);
  SetupRenderPass();
}

Canvas() [3/3]

impeller::Canvas::Canvas ( ContentContext &  renderer, const RenderTarget &  render_target, bool  is_onscreen, bool  requires_readback, IRect32  cull_rect  )

explicit

Definition at line 327 of file canvas.cc.

    : renderer_(renderer),
      render_target_(render_target),
      is_onscreen_(is_onscreen),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  Initialize(Rect::MakeLTRB(cull_rect.GetLeft(), cull_rect.GetTop(),
                            cull_rect.GetRight(), cull_rect.GetBottom()));
  SetupRenderPass();
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), and impeller::TRect< Scalar >::MakeLTRB().

~Canvas()

flutter::Canvas::~Canvas ( )

default

Definition at line 48 of file canvas.cc.

{}

Member Function Documentation

ClipGeometry()

void impeller::Canvas::ClipGeometry	(	const Geometry &	geometry,
		Entity::ClipOperation	clip_op,
		bool	is_aa = true
	)

Definition at line 1133 of file canvas.cc.

                                      {
  if (IsSkipping()) {
    return;
  }
 
  // Ideally the clip depth would be greater than the current rendering
  // depth because any rendering calls that follow this clip operation will
  // pre-increment the depth and then be rendering above our clip depth,
  // but that case will be caught by the CHECK in AddRenderEntity above.
  // In practice we sometimes have a clip set with no rendering after it
  // and in such cases the current depth will equal the clip depth.
  // Eventually the DisplayList should optimize these out, but it is hard
  // to know if a clip will actually be used in advance of storing it in
  // the DisplayList buffer.
  // See https://github.com/flutter/flutter/issues/147021
  FML_DCHECK(current_depth_ <= transform_stack_.back().clip_depth)
      << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
  uint32_t clip_depth = transform_stack_.back().clip_depth;
 
  const Matrix clip_transform =
      Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) *
      GetCurrentTransform();
 
  std::optional<Rect> clip_coverage = geometry.GetCoverage(clip_transform);
  if (!clip_coverage.has_value()) {
    return;
  }
 
  ClipContents clip_contents(
      clip_coverage.value(),
      /*is_axis_aligned_rect=*/geometry.IsAxisAlignedRect() &&
          GetCurrentTransform().IsTranslationScaleOnly());
  clip_contents.SetClipOperation(clip_op);
 
  EntityPassClipStack::ClipStateResult clip_state_result =
      clip_coverage_stack_.RecordClip(
          clip_contents,                                     //
          /*transform=*/clip_transform,                      //
          /*global_pass_position=*/GetGlobalPassPosition(),  //
          /*clip_depth=*/clip_depth,                         //
          /*clip_height_floor=*/GetClipHeightFloor(),        //
          /*is_aa=*/is_aa);
 
  if (clip_state_result.clip_did_change) {
    // We only need to update the pass scissor if the clip state has changed.
    SetClipScissor(
        clip_coverage_stack_.CurrentClipCoverage(),
        *render_passes_.back().GetInlinePassContext()->GetRenderPass(),
        GetGlobalPassPosition());
  }
 
  ++transform_stack_.back().clip_height;
  ++transform_stack_.back().num_clips;
 
  if (!clip_state_result.should_render) {
    return;
  }
 
  // Note: this is a bit of a hack. Its not possible to construct a geometry
  // result without begninning the render pass. We should refactor the geometry
  // objects so that they only need a reference to the render pass size and/or
  // orthographic transform.
  Entity entity;
  entity.SetTransform(clip_transform);
  entity.SetClipDepth(clip_depth);
 
  GeometryResult geometry_result = geometry.GetPositionBuffer(
      renderer_,                                                      //
      entity,                                                         //
      *render_passes_.back().GetInlinePassContext()->GetRenderPass()  //
  );
  clip_contents.SetGeometry(geometry_result);
  clip_coverage_stack_.GetLastReplayResult().clip_contents.SetGeometry(
      geometry_result);
 
  clip_contents.Render(
      renderer_, *render_passes_.back().GetInlinePassContext()->GetRenderPass(),
      clip_depth);
}

References impeller::EntityPassClipStack::ReplayResult::clip_contents, impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::CurrentClipCoverage(), FML_DCHECK, impeller::Geometry::GetCoverage(), GetCurrentTransform(), impeller::EntityPassClipStack::GetLastReplayResult(), impeller::Geometry::GetPositionBuffer(), impeller::Geometry::IsAxisAlignedRect(), impeller::Matrix::MakeTranslation(), impeller::EntityPassClipStack::RecordClip(), impeller::ClipContents::Render(), impeller::Entity::SetClipDepth(), impeller::ClipContents::SetClipOperation(), impeller::ClipContents::SetGeometry(), impeller::Entity::SetTransform(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

Referenced by impeller::DlDispatcherBase::clipOval(), impeller::DlDispatcherBase::clipPath(), impeller::DlDispatcherBase::clipRect(), impeller::DlDispatcherBase::clipRoundRect(), and impeller::DlDispatcherBase::clipRoundSuperellipse().

Concat()

void impeller::Canvas::Concat

(

const Matrix &

transform

)

Definition at line 356 of file canvas.cc.

                                           {
  transform_stack_.back().transform = GetCurrentTransform() * transform;
}

References GetCurrentTransform(), and transform.

Referenced by DrawTextFrame(), Rotate(), Scale(), Scale(), Skew(), Transform(), and Translate().

DrawArc()

void impeller::Canvas::DrawArc	(	const Arc &	arc,
		const Paint &	paint
	)

Definition at line 912 of file canvas.cc.

                                                       {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kFill) {
    ArcGeometry geom(arc);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
    return;
  }
 
  const Rect& oval_bounds = arc.GetOvalBounds();
  if (paint.stroke.width > oval_bounds.GetSize().MaxDimension()) {
    // This is a special case for rendering arcs whose stroke width is so large
    // you are effectively drawing a sector of a circle.
    // https://github.com/flutter/flutter/issues/158567
    Arc expanded_arc(oval_bounds.Expand(Size(paint.stroke.width * 0.5f)),
                     arc.GetStart(), arc.GetSweep(), true);
 
    ArcGeometry geom(expanded_arc);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
    return;
  }
 
  // IncludeCenter incurs lots of extra work for stroking an arc, including:
  // - It introduces segments to/from the center point (not too hard).
  // - It introduces joins on those segments (a bit more complicated).
  // - Even if the sweep is >=360 degrees, we still draw the segment to
  //   the center and it basically looks like a pie cut into the complete
  //   boundary circle, as if the slice were cut, but not extracted
  //   (hard to express as a continuous kTriangleStrip).
  if (!arc.IncludeCenter()) {
    if (arc.IsFullCircle()) {
      return DrawOval(oval_bounds, paint);
    }
 
    // Our fast stroking code only works for circular bounds as it assumes
    // that the inner and outer radii can be scaled along each angular step
    // of the arc - which is not true for elliptical arcs where the inner
    // and outer samples are perpendicular to the traveling direction of the
    // elliptical curve which may not line up with the center of the bounds.
    if (oval_bounds.IsSquare()) {
      ArcGeometry geom(arc, paint.stroke);
      AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
      return;
    }
  }
 
  ArcStrokeGeometry geom(arc, paint.stroke);
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

References impeller::Paint::blend_mode, DrawOval(), impeller::TRect< T >::Expand(), GetCurrentTransform(), impeller::Arc::GetOvalBounds(), impeller::TRect< T >::GetSize(), impeller::Arc::GetStart(), impeller::Arc::GetSweep(), impeller::Arc::IncludeCenter(), impeller::Arc::IsFullCircle(), impeller::TRect< T >::IsSquare(), impeller::Paint::kFill, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, impeller::Paint::style, and impeller::StrokeParameters::width.

Referenced by impeller::DlDispatcherBase::drawArc().

DrawAtlas()

void impeller::Canvas::DrawAtlas	(	const std::shared_ptr< AtlasContents > &	atlas_contents,
		const Paint &	paint
	)

Definition at line 1429 of file canvas.cc.

                                           {
  atlas_contents->SetAlpha(paint.color.alpha);
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(renderer_, atlas_contents));
 
  AddRenderEntityToCurrentPass(entity);
}

References impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransform(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Paint::WithFilters().

Referenced by impeller::DlDispatcherBase::drawAtlas().

DrawCircle()

void impeller::Canvas::DrawCircle	(	const Point &	center,
		Scalar	radius,
		const Paint &	paint
	)

Definition at line 1096 of file canvas.cc.

                                            {
  if (IsShadowBlurDrawOperation(paint)) {
    Rect bounds = Rect::MakeCircleBounds(center, radius);
    RRectBlurShape shape(bounds, radius);
    if (AttemptDrawBlur(shape, paint)) {
      return;
    }
  }
 
  if (renderer_.GetContext()->GetFlags().use_sdfs &&
      IsCompatibleWithSDFRendering(paint)) {
    auto params = UberSDFParameters::MakeCircle(
        /*color=*/paint.color, /*center=*/center, /*radius=*/radius,
        /*stroke=*/paint.GetStroke());
    AddRenderSDFEntityToCurrentPass(paint, params);
    return;
  }
 
  if (AttemptDrawAntialiasedCircle(center, radius, paint)) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kStroke) {
    CircleGeometry geom(center, radius, paint.stroke.width);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    CircleGeometry geom(center, radius);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, impeller::Paint::color, impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::Paint::GetStroke(), IsCompatibleWithSDFRendering(), impeller::Paint::kStroke, impeller::UberSDFParameters::MakeCircle(), impeller::TRect< Scalar >::MakeCircleBounds(), params, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, impeller::Paint::style, and impeller::StrokeParameters::width.

Referenced by impeller::DlDispatcherBase::drawCircle(), and DrawOval().

DrawDashedLine()

void impeller::Canvas::DrawDashedLine	(	const Point &	p0,
		const Point &	p1,
		Scalar	on_length,
		Scalar	off_length,
		const Paint &	paint
	)

Definition at line 800 of file canvas.cc.

                                                {
  // Reasons to defer to regular DrawLine:
  // - performance for degenerate and "regular line" cases
  // - length is non-positive - DrawLine will draw appropriate "dot"
  // - off_length is non-positive - no gaps, DrawLine will draw it solid
  // - on_length is negative - invalid dashing
  //
  // Note that a 0 length "on" dash will draw "dot"s every "off" distance
  // apart so we proceed with the dashing process in that case.
  Scalar length = p0.GetDistance(p1);
  if (length > 0.0f && on_length >= 0.0f && off_length > 0.0f) {
    Entity entity;
    entity.SetTransform(GetCurrentTransform());
    entity.SetBlendMode(paint.blend_mode);
 
    StrokeDashedLineGeometry geom(p0, p1, on_length, off_length, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    DrawLine(p0, p1, paint);
  }
}

References impeller::Paint::blend_mode, DrawLine(), GetCurrentTransform(), impeller::TPoint< T >::GetDistance(), length, p1, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), and impeller::Paint::stroke.

Referenced by impeller::DlDispatcherBase::drawDashedLine().

DrawDiffRoundRect()

void impeller::Canvas::DrawDiffRoundRect	(	const RoundRect &	outer,
		const RoundRect &	inner,
		const Paint &	paint
	)

Definition at line 1011 of file canvas.cc.

                                                   {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kFill) {
    FillDiffRoundRectGeometry geom(outer, inner);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    StrokeDiffRoundRectGeometry geom(outer, inner, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Paint::kFill, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, and impeller::Paint::style.

Referenced by impeller::DlDispatcherBase::drawDiffRoundRect().

DrawImage()

void impeller::Canvas::DrawImage	(	const std::shared_ptr< Texture > &	image,
		Point	offset,
		const Paint &	paint,
		const SamplerDescriptor &	sampler = {}
	)

Definition at line 1233 of file canvas.cc.

                                                         {
  if (!image) {
    return;
  }
 
  const Rect source = Rect::MakeSize(image->GetSize());
  const Rect dest = source.Shift(offset);
 
  DrawImageRect(image, source, dest, paint, sampler);
}

References DrawImageRect(), image, impeller::TRect< Scalar >::MakeSize(), and impeller::TRect< T >::Shift().

DrawImageRect()

void impeller::Canvas::DrawImageRect	(	const std::shared_ptr< Texture > &	image,
		Rect	source,
		Rect	dest,
		const Paint &	paint,
		const SamplerDescriptor &	sampler = {},
		SourceRectConstraint	src_rect_constraint = SourceRectConstraint::kFast
	)

Definition at line 1247 of file canvas.cc.

                                                                     {
  if (!image || source.IsEmpty() || dest.IsEmpty()) {
    return;
  }
 
  ISize size = image->GetSize();
  if (size.IsEmpty()) {
    return;
  }
 
  std::optional<Rect> clipped_source =
      source.Intersection(Rect::MakeSize(size));
  if (!clipped_source) {
    return;
  }
 
  if (AttemptColorFilterOptimization(image, source, dest, paint, sampler,
                                     src_rect_constraint)) {
    return;
  }
 
  if (*clipped_source != source) {
    Scalar sx = dest.GetWidth() / source.GetWidth();
    Scalar sy = dest.GetHeight() / source.GetHeight();
    Scalar tx = dest.GetLeft() - source.GetLeft() * sx;
    Scalar ty = dest.GetTop() - source.GetTop() * sy;
    Matrix src_to_dest = Matrix::MakeTranslateScale({sx, sy, 1}, {tx, ty, 0});
    dest = clipped_source->TransformBounds(src_to_dest);
  }
 
  auto texture_contents = TextureContents::MakeRect(dest);
  texture_contents->SetTexture(image);
  texture_contents->SetSourceRect(*clipped_source);
  texture_contents->SetStrictSourceRect(src_rect_constraint ==
                                        SourceRectConstraint::kStrict);
  texture_contents->SetSamplerDescriptor(sampler);
  texture_contents->SetOpacity(paint.color.alpha);
  texture_contents->SetDeferApplyingOpacity(paint.HasColorFilter());
 
  Entity entity;
  entity.SetBlendMode(paint.blend_mode);
  entity.SetTransform(GetCurrentTransform());
 
  if (!paint.mask_blur_descriptor.has_value()) {
    entity.SetContents(
        paint.WithFilters(renderer_, std::move(texture_contents)));
    AddRenderEntityToCurrentPass(entity);
    return;
  }
 
  FillRectGeometry out_rect(Rect{});
 
  entity.SetContents(paint.WithFilters(
      renderer_,
      paint.mask_blur_descriptor->CreateMaskBlur(texture_contents, &out_rect)));
  AddRenderEntityToCurrentPass(entity);
}

References impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransform(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::Paint::HasColorFilter(), image, impeller::TRect< T >::Intersection(), impeller::TRect< T >::IsEmpty(), impeller::kStrict, impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeTranslateScale(), impeller::Paint::mask_blur_descriptor, impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::TRect< T >::TransformBounds(), and impeller::Paint::WithFilters().

Referenced by DrawImage(), impeller::DlDispatcherBase::drawImageRect(), and impeller::NinePatchConverter::DrawNinePatch().

DrawLine()

void impeller::Canvas::DrawLine	(	const Point &	p0,
		const Point &	p1,
		const Paint &	paint,
		bool	reuse_depth = false
	)

Definition at line 777 of file canvas.cc.

                                        {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  auto geometry = std::make_unique<LineGeometry>(p0, p1, paint.stroke);
 
  if ((renderer_.GetContext()->GetFlags().antialiased_lines ||
       renderer_.GetContext()->GetFlags().use_sdfs) &&
      !paint.color_filter && !paint.invert_colors && !paint.image_filter &&
      !paint.mask_blur_descriptor.has_value() && !paint.color_source) {
    auto contents = LineContents::Make(std::move(geometry), paint.color);
    entity.SetContents(std::move(contents));
    AddRenderEntityToCurrentPass(entity, reuse_depth);
  } else {
    AddRenderEntityWithFiltersToCurrentPass(entity, geometry.get(), paint,
                                            /*reuse_depth=*/reuse_depth);
  }
}

References impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_filter, impeller::Paint::color_source, impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::Paint::image_filter, impeller::Paint::invert_colors, impeller::LineContents::Make(), impeller::Paint::mask_blur_descriptor, p1, impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Paint::stroke.

Referenced by DrawDashedLine(), impeller::DlDispatcherBase::drawLine(), impeller::DlDispatcherBase::drawPoints(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawOval()

void impeller::Canvas::DrawOval	(	const Rect &	rect,
		const Paint &	paint
	)

Definition at line 857 of file canvas.cc.

                                                          {
  // TODO(jonahwilliams): This additional condition avoids an assert in the
  // stroke circle geometry generator. I need to verify the condition that this
  // assert prevents.
  if (rect.IsSquare() && (paint.style == Paint::Style::kFill ||
                          (paint.style == Paint::Style::kStroke &&
                           paint.stroke.width < rect.GetWidth()))) {
    // Circles have slightly less overhead and can do stroking
    DrawCircle(rect.GetCenter(), rect.GetWidth() * 0.5f, paint);
    return;
  }
 
  if (IsShadowBlurDrawOperation(paint)) {
    if (rect.IsSquare()) {
      // RRectBlurShape takes the corner radii which are half of the
      // overall width and height of the DrawOval bounds rect.
      RRectBlurShape shape(rect, rect.GetWidth() * 0.5f);
      if (AttemptDrawBlur(shape, paint)) {
        return;
      }
    } else {
      EllipsePathSource source(rect);
      if (AttemptDrawBlurredPathSource(source, paint)) {
        return;
      }
    }
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (renderer_.GetContext()->GetFlags().use_sdfs &&
      IsCompatibleWithSDFRendering(paint)) {
    UberSDFParameters params;
 
    if (paint.style == Paint::Style::kStroke) {
      params = UberSDFParameters::MakeOval(paint.color, rect, paint.stroke);
    } else {
      params = UberSDFParameters::MakeOval(paint.color, rect, std::nullopt);
    }
 
    AddRenderSDFEntityToCurrentPass(paint, params);
    return;
  }
 
  if (paint.style == Paint::Style::kStroke) {
    StrokeEllipseGeometry geom(rect, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    EllipseGeometry geom(rect);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, impeller::Paint::color, DrawCircle(), impeller::TRect< T >::GetCenter(), impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::TRect< T >::GetWidth(), IsCompatibleWithSDFRendering(), impeller::TRect< T >::IsSquare(), impeller::Paint::kFill, impeller::Paint::kStroke, impeller::UberSDFParameters::MakeOval(), params, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, impeller::Paint::style, and impeller::StrokeParameters::width.

Referenced by DrawArc(), impeller::DlDispatcherBase::drawOval(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawPaint()

void impeller::Canvas::DrawPaint

(

const Paint &

paint

)

Definition at line 447 of file canvas.cc.

                                         {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  CoverGeometry geom;
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Entity::SetBlendMode(), and impeller::Entity::SetTransform().

Referenced by impeller::DlDispatcherBase::drawColor(), and impeller::DlDispatcherBase::drawPaint().

DrawPath()

void impeller::Canvas::DrawPath	(	const flutter::DlPath &	path,
		const Paint &	paint
	)

Definition at line 427 of file canvas.cc.

                                                                   {
  if (IsShadowBlurDrawOperation(paint)) {
    if (AttemptDrawBlurredPathSource(path, paint)) {
      return;
    }
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kFill) {
    FillPathGeometry geom(path);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    StrokePathGeometry geom(path, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Paint::kFill, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, and impeller::Paint::style.

Referenced by impeller::DlDispatcherBase::drawPath(), DrawTextFrame(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawPoints()

void impeller::Canvas::DrawPoints	(	const Point	points[],
		uint32_t	count,
		Scalar	radius,
		const Paint &	paint,
		PointStyle	point_style
	)

Definition at line 1215 of file canvas.cc.

                                                {
  if (radius <= 0) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  PointFieldGeometry geom(points, count, radius,
                          /*round=*/point_style == PointStyle::kRound);
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::kRound, points, impeller::Entity::SetBlendMode(), and impeller::Entity::SetTransform().

Referenced by impeller::DlDispatcherBase::drawPoints().

DrawRect()

void impeller::Canvas::DrawRect	(	const Rect &	rect,
		const Paint &	paint
	)

Definition at line 826 of file canvas.cc.

                                                          {
  if (IsShadowBlurDrawOperation(paint)) {
    RRectBlurShape shape(rect, 0.0f);
    if (AttemptDrawBlur(shape, paint)) {
      return;
    }
  }
 
  if (renderer_.GetContext()->GetFlags().use_sdfs &&
      IsCompatibleWithSDFRendering(paint)) {
    auto params = UberSDFParameters::MakeRect(
        /*color=*/paint.color,
        /*rect=*/rect,
        /*stroke=*/paint.GetStroke());
    AddRenderSDFEntityToCurrentPass(paint, params);
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kStroke) {
    StrokeRectGeometry geom(rect, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    FillRectGeometry geom(rect);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, impeller::Paint::color, impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::Paint::GetStroke(), IsCompatibleWithSDFRendering(), impeller::Paint::kStroke, impeller::UberSDFParameters::MakeRect(), params, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, and impeller::Paint::style.

Referenced by impeller::DlDispatcherBase::drawRect(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawRoundRect()

void impeller::Canvas::DrawRoundRect	(	const RoundRect &	rect,
		const Paint &	paint
	)

Definition at line 964 of file canvas.cc.

                                                                          {
  if (IsShadowBlurDrawOperation(paint)) {
    if (AttemptDrawBlurredRRect(round_rect, paint)) {
      return;
    }
  }
 
  const RoundingRadii& radii = round_rect.GetRadii();
 
  if (renderer_.GetContext()->GetFlags().use_sdfs &&
      IsCompatibleWithSDFRendering(paint) && radii.AreAllCornersCircular()) {
    auto params = UberSDFParameters::MakeRoundedRect(
        /*color=*/paint.color,
        /*rect=*/round_rect.GetBounds(),
        /*radii=*/radii,
        /*stroke=*/paint.style == Paint::Style::kStroke
            ? std::make_optional(paint.stroke)
            : std::nullopt);
    AddRenderSDFEntityToCurrentPass(paint, params);
    return;
  }
 
  if (round_rect.GetRadii().AreAllCornersSame() &&
      paint.style == Paint::Style::kFill) {
    Entity entity;
    entity.SetTransform(GetCurrentTransform());
    entity.SetBlendMode(paint.blend_mode);
 
    RoundRectGeometry geom(round_rect.GetBounds(),
                           round_rect.GetRadii().top_left);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kFill) {
    FillRoundRectGeometry geom(round_rect);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    StrokeRoundRectGeometry geom(round_rect, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersSame(), impeller::Paint::blend_mode, impeller::Paint::color, impeller::RoundRect::GetBounds(), impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::RoundRect::GetRadii(), IsCompatibleWithSDFRendering(), impeller::Paint::kFill, impeller::Paint::kStroke, impeller::UberSDFParameters::MakeRoundedRect(), params, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, impeller::Paint::style, and impeller::RoundingRadii::top_left.

Referenced by impeller::DlDispatcherBase::drawRoundRect(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawRoundSuperellipse()

void impeller::Canvas::DrawRoundSuperellipse	(	const RoundSuperellipse &	rse,
		const Paint &	paint
	)

Definition at line 1027 of file canvas.cc.

                                                       {
  if (IsShadowBlurDrawOperation(paint)) {
    if (AttemptDrawBlurredRSuperellipse(round_superellipse, paint)) {
      return;
    }
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (renderer_.GetContext()->GetFlags().use_sdfs &&
      IsCompatibleWithSDFRendering(paint)) {
    auto round_superellipse_params = RoundSuperellipseParam::MakeBoundsRadii(
        round_superellipse.GetBounds(), round_superellipse.GetRadii());
 
    if (round_superellipse_params.all_corners_same) {
      auto params = UberSDFParameters::MakeRoundedSuperellipse(
          /*color=*/paint.color,
          /*bounds=*/round_superellipse.GetBounds(),
          /*round_superellipse_params=*/round_superellipse_params,
          /*stroke=*/paint.GetStroke());
 
      AddRenderSDFEntityToCurrentPass(paint, params);
      return;
    } else {
      auto contents = ComplexRoundedSuperellipseContents::Make(
          /*color=*/paint.color_source ? Color::White() : paint.color,
          /*bounds=*/round_superellipse.GetBounds(),
          /*round_superellipse_params=*/round_superellipse_params,
          /*stroke=*/paint.GetStroke());
 
      const Geometry* geom = contents->GetGeometry();
 
      if (paint.color_source) {
        std::shared_ptr<Contents> color_source_contents =
            paint.CreateContents(renderer_, geom);
        std::shared_ptr<Contents> final_contents =
            ColorFilterContents::MakeBlend(
                BlendMode::kSrcIn, {FilterInput::Make(std::move(contents)),
                                    FilterInput::Make(color_source_contents)});
 
        Paint new_paint = paint;
        new_paint.color_source = nullptr;
        AddRenderEntityWithFiltersToCurrentPass(entity, geom, new_paint,
                                                /*reuse_depth=*/false,
                                                /*override_contents=*/
                                                std::move(final_contents));
      } else {
        AddRenderEntityWithFiltersToCurrentPass(entity, geom, paint,
                                                /*reuse_depth=*/false,
                                                /*override_contents=*/
                                                std::move(contents));
      }
      return;
    }
  }
 
  if (paint.style == Paint::Style::kFill) {
    RoundSuperellipseGeometry geom(round_superellipse.GetBounds(),
                                   round_superellipse.GetRadii());
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    StrokeRoundSuperellipseGeometry geom(round_superellipse, paint.stroke);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_source, impeller::Paint::CreateContents(), impeller::RoundSuperellipse::GetBounds(), impeller::ContentContext::GetContext(), GetCurrentTransform(), impeller::RoundSuperellipse::GetRadii(), impeller::Paint::GetStroke(), IsCompatibleWithSDFRendering(), impeller::Paint::kFill, impeller::kSrcIn, impeller::ComplexRoundedSuperellipseContents::Make(), impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::RoundSuperellipseParam::MakeBoundsRadii(), impeller::UberSDFParameters::MakeRoundedSuperellipse(), params, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke, impeller::Paint::style, and impeller::Color::White().

Referenced by impeller::DlDispatcherBase::drawRoundSuperellipse(), and impeller::testing::TEST_P().

DrawTextFrame()

void impeller::Canvas::DrawTextFrame	(	const std::shared_ptr< TextFrame > &	text_frame,
		Point	position,
		const Paint &	paint
	)

Definition at line 1973 of file canvas.cc.

                                               {
  Scalar max_scale = GetCurrentTransform().GetMaxBasisLengthXY();
  if (max_scale * text_frame->GetFont().GetMetrics().point_size >
      kMaxTextScale) {
    fml::StatusOr<flutter::DlPath> path = text_frame->GetPath();
    if (path.ok()) {
      Save(1);
      Concat(Matrix::MakeTranslation(position));
      DrawPath(path.value(), paint);
      Restore();
      return;
    }
  }
 
  Entity entity;
  entity.SetClipDepth(GetClipHeight());
  entity.SetBlendMode(paint.blend_mode);
 
  auto text_contents = std::make_shared<TextContents>();
  text_contents->SetTextFrame(text_frame);
  text_contents->SetPosition(position);
  text_contents->SetScreenTransform(GetCurrentTransform());
  text_contents->SetForceTextColor(paint.mask_blur_descriptor.has_value());
  text_contents->SetColor(paint.color);
  text_contents->SetTextProperties(paint.color, paint.GetStroke());
 
  entity.SetTransform(GetCurrentTransform().Translate(position));
 
  if (AttemptBlurredTextOptimization(text_frame, text_contents, entity,
                                     paint)) {
    return;
  }
 
  entity.SetContents(paint.WithFilters(renderer_, std::move(text_contents)));
  AddRenderEntityToCurrentPass(entity, false);
}

References impeller::Paint::blend_mode, impeller::Paint::color, Concat(), DrawPath(), GetCurrentTransform(), impeller::Matrix::GetMaxBasisLengthXY(), impeller::Paint::GetStroke(), impeller::kMaxTextScale, impeller::Matrix::MakeTranslation(), impeller::Paint::mask_blur_descriptor, Restore(), Save(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), Translate(), and impeller::Paint::WithFilters().

Referenced by impeller::DlDispatcherBase::drawText().

DrawVertices()

void impeller::Canvas::DrawVertices	(	const std::shared_ptr< VerticesGeometry > &	vertices,
		BlendMode	blend_mode,
		const Paint &	paint
	)

Definition at line 1314 of file canvas.cc.

                                              {
  // Override the blend mode with kDestination in order to match the behavior
  // of Skia's SK_LEGACY_IGNORE_DRAW_VERTICES_BLEND_WITH_NO_SHADER flag, which
  // is enabled when the Flutter engine builds Skia.
  if (!paint.color_source) {
    blend_mode = BlendMode::kDst;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  // If there are no vertex colors.
  if (UseColorSourceContents(vertices, paint)) {
    AddRenderEntityWithFiltersToCurrentPass(entity, vertices.get(), paint);
    return;
  }
 
  // If the blend mode is destination don't bother to bind or create a texture.
  if (blend_mode == BlendMode::kDst) {
    auto contents = std::make_shared<VerticesSimpleBlendContents>();
    contents->SetBlendMode(blend_mode);
    contents->SetAlpha(paint.color.alpha);
    contents->SetGeometry(vertices);
    entity.SetContents(paint.WithFilters(renderer_, std::move(contents)));
    AddRenderEntityToCurrentPass(entity);
    return;
  }
 
  // If there is a texture, use this directly. Otherwise render the color
  // source to a texture.
  if (paint.color_source &&
      paint.color_source->type() == flutter::DlColorSourceType::kImage) {
    const flutter::DlImageColorSource* image_color_source =
        paint.color_source->asImage();
    FML_DCHECK(image_color_source);
    auto texture =
        image_color_source->image()->asImpellerImage()->GetCachedTexture(
            renderer_);
    FML_DCHECK(texture);
    auto x_tile_mode = static_cast<Entity::TileMode>(
        image_color_source->horizontal_tile_mode());
    auto y_tile_mode =
        static_cast<Entity::TileMode>(image_color_source->vertical_tile_mode());
    auto sampler_descriptor =
        skia_conversions::ToSamplerDescriptor(image_color_source->sampling());
    auto effect_transform = image_color_source->matrix();
 
    auto contents = std::make_shared<VerticesSimpleBlendContents>();
    contents->SetBlendMode(blend_mode);
    contents->SetAlpha(paint.color.alpha);
    contents->SetGeometry(vertices);
    contents->SetEffectTransform(effect_transform);
    contents->SetTexture(texture);
    contents->SetTileMode(x_tile_mode, y_tile_mode);
    contents->SetSamplerDescriptor(sampler_descriptor);
 
    entity.SetContents(paint.WithFilters(renderer_, std::move(contents)));
    AddRenderEntityToCurrentPass(entity);
    return;
  }
 
  auto src_paint = paint;
  src_paint.color = paint.color.WithAlpha(1.0);
 
  std::shared_ptr<ColorSourceContents> src_contents =
      src_paint.CreateContents(renderer_, vertices.get());
 
  // If the color source has an intrinsic size, then we use that to
  // create the src contents as a simplification. Otherwise we use
  // the extent of the texture coordinates to determine how large
  // the src contents should be. If neither has a value we fall back
  // to using the geometry coverage data.
  Rect src_coverage;
  auto size = src_contents->GetColorSourceSize();
  if (size.has_value()) {
    src_coverage = Rect::MakeXYWH(0, 0, size->width, size->height);
  } else {
    auto cvg = vertices->GetCoverage(Matrix{});
    FML_CHECK(cvg.has_value());
    auto texture_coverage = vertices->GetTextureCoordinateCoverage();
    if (texture_coverage.has_value()) {
      src_coverage =
          Rect::MakeOriginSize(texture_coverage->GetOrigin(),
                               texture_coverage->GetSize().Max({1, 1}));
    } else {
      // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
      src_coverage = cvg.value();
    }
  }
  clip_geometry_.push_back(Geometry::MakeRect(Rect::Round(src_coverage)));
  src_contents =
      src_paint.CreateContents(renderer_, clip_geometry_.back().get());
 
  auto contents = std::make_shared<VerticesSimpleBlendContents>();
  contents->SetBlendMode(blend_mode);
  contents->SetAlpha(paint.color.alpha);
  contents->SetGeometry(vertices);
  contents->SetLazyTextureCoverage(src_coverage);
  contents->SetLazyTexture(
      [src_contents, src_coverage](
          const ContentContext& renderer) -> std::shared_ptr<Texture> {
        // Applying the src coverage as the coverage limit prevents the 1px
        // coverage pad from adding a border that is picked up by developer
        // specified UVs.
        auto snapshot = src_contents->RenderToSnapshot(
            renderer, {}, {.coverage_limit = Rect::Round(src_coverage)});
        return snapshot.has_value() ? snapshot->texture : nullptr;
      });
  entity.SetContents(paint.WithFilters(renderer_, std::move(contents)));
  AddRenderEntityToCurrentPass(entity);
}

References impeller::Color::alpha, flutter::DlColorSource::asImage(), impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_source, FML_CHECK, FML_DCHECK, GetCurrentTransform(), flutter::DlImageColorSource::horizontal_tile_mode(), flutter::DlImageColorSource::image(), impeller::kDst, flutter::kImage, impeller::TRect< Scalar >::MakeOriginSize(), impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlMatrixColorSourceBase::matrix(), impeller::TRect< Scalar >::Round(), flutter::DlImageColorSource::sampling(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), texture, impeller::skia_conversions::ToSamplerDescriptor(), flutter::DlAttribute< D, T >::type(), flutter::DlImageColorSource::vertical_tile_mode(), impeller::Color::WithAlpha(), and impeller::Paint::WithFilters().

Referenced by impeller::CanvasDlDispatcher::drawVertices(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

EndReplay()

void impeller::Canvas::EndReplay

(

)

Definition at line 2441 of file canvas.cc.

                       {
  FML_DCHECK(render_passes_.size() == 1u);
  render_passes_.back().GetInlinePassContext()->GetRenderPass();
  render_passes_.back().GetInlinePassContext()->EndPass(
      /*is_onscreen=*/!requires_readback_ && is_onscreen_);
  backdrop_data_.clear();
 
  // If requires_readback_ was true, then we rendered to an offscreen texture
  // instead of to the onscreen provided in the render target. Now we need to
  // draw or blit the offscreen back to the onscreen.
  if (requires_readback_) {
    BlitToOnscreen(/*is_onscreen_=*/is_onscreen_);
  }
  if (!EnsureFinalMipmapGeneration()) {
    VALIDATION_LOG << "Failed to generate onscreen mipmaps.";
  }
  if (!renderer_.GetContext()->FlushCommandBuffers()) {
    // Not much we can do.
    VALIDATION_LOG << "Failed to submit command buffers";
  }
  render_passes_.clear();
  renderer_.GetRenderTargetCache()->End();
  clip_geometry_.clear();
 
  Reset();
  Initialize(initial_cull_rect_);
}

References FML_DCHECK, and VALIDATION_LOG.

Referenced by impeller::CanvasDlDispatcher::FinishRecording(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

EnsureFinalMipmapGeneration()

bool impeller::Canvas::EnsureFinalMipmapGeneration

(

)

const

For picture snapshots we need addition steps to verify that final mipmaps are generated.

Definition at line 2423 of file canvas.cc.

                                               {
  if (!render_target_.GetRenderTargetTexture()->NeedsMipmapGeneration()) {
    return true;
  }
  std::shared_ptr<CommandBuffer> cmd_buffer =
      renderer_.GetContext()->CreateCommandBuffer();
  if (!cmd_buffer) {
    return false;
  }
  std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
  if (!blit_pass) {
    return false;
  }
  blit_pass->GenerateMipmap(render_target_.GetRenderTargetTexture());
  blit_pass->EncodeCommands();
  return renderer_.GetContext()->EnqueueCommandBuffer(std::move(cmd_buffer));
}

GetCurrentTransform()

const Matrix & impeller::Canvas::GetCurrentTransform

(

)

const

Definition at line 372 of file canvas.cc.

                                                {
  return transform_stack_.back().transform;
}

Referenced by ClipGeometry(), Concat(), DrawArc(), DrawAtlas(), DrawCircle(), DrawDashedLine(), DrawDiffRoundRect(), impeller::DlDispatcherBase::drawDisplayList(), DrawImageRect(), DrawLine(), DrawOval(), DrawPaint(), DrawPath(), DrawPoints(), DrawRect(), DrawRoundRect(), DrawRoundSuperellipse(), impeller::DlDispatcherBase::drawShadow(), DrawTextFrame(), DrawVertices(), and PreConcat().

GetLocalCoverageLimit()

std::optional< Rect > impeller::Canvas::GetLocalCoverageLimit

(

)

const

Return the culling bounds of the current render target, or nullopt if there is no coverage.

Definition at line 1514 of file canvas.cc.

                                                      {
  if (!clip_coverage_stack_.HasCoverage()) {
    // The current clip is empty. This means the pass texture won't be
    // visible, so skip it.
    return std::nullopt;
  }
 
  std::optional<Rect> maybe_current_clip_coverage =
      clip_coverage_stack_.CurrentClipCoverage();
  if (!maybe_current_clip_coverage.has_value()) {
    return std::nullopt;
  }
 
  Rect current_clip_coverage = maybe_current_clip_coverage.value();
 
  FML_CHECK(!render_passes_.empty());
  const LazyRenderingConfig& back_render_pass = render_passes_.back();
  std::shared_ptr<Texture> back_texture =
      back_render_pass.GetInlinePassContext()->GetTexture();
  FML_CHECK(back_texture) << "Context is valid:"
                          << back_render_pass.GetInlinePassContext()->IsValid();
 
  // The maximum coverage of the subpass. Subpasses textures should never
  // extend outside the parent pass texture or the current clip coverage.
  std::optional<Rect> maybe_coverage_limit =
      Rect::MakeOriginSize(GetGlobalPassPosition(),
                           Size(back_texture->GetSize()))
          .Intersection(current_clip_coverage);
 
  if (!maybe_coverage_limit.has_value() || maybe_coverage_limit->IsEmpty()) {
    return std::nullopt;
  }
 
  return maybe_coverage_limit->Intersection(
      Rect::MakeSize(render_target_.GetRenderTargetSize()));
}

References impeller::EntityPassClipStack::CurrentClipCoverage(), FML_CHECK, impeller::LazyRenderingConfig::GetInlinePassContext(), impeller::RenderTarget::GetRenderTargetSize(), impeller::InlinePassContext::GetTexture(), impeller::EntityPassClipStack::HasCoverage(), impeller::TRect< T >::Intersection(), impeller::InlinePassContext::IsValid(), impeller::TRect< Scalar >::MakeOriginSize(), and impeller::TRect< Scalar >::MakeSize().

Referenced by impeller::DlDispatcherBase::drawDisplayList(), and SaveLayer().

GetMaxOpDepth()

uint64_t impeller::Canvas::GetMaxOpDepth ( ) const

inline

Definition at line 257 of file canvas.h.

{ return transform_stack_.back().clip_depth; }

GetOpDepth()

uint64_t impeller::Canvas::GetOpDepth ( ) const

inline

Definition at line 255 of file canvas.h.

{ return current_depth_; }

GetSaveCount()

size_t impeller::Canvas::GetSaveCount

(

)

const

Definition at line 411 of file canvas.cc.

                                  {
  return transform_stack_.size();
}

Referenced by impeller::DlDispatcherBase::drawDisplayList(), and RestoreToCount().

IsCompatibleWithSDFRendering()

bool impeller::Canvas::IsCompatibleWithSDFRendering ( const Paint &  paint )

static

Returns true if the paint is compatible with SDF rendering.

Visible for testing.

Definition at line 2469 of file canvas.cc.

                                                            {
  if (!paint.anti_alias) {
    return false;
  }
  if (paint.mask_blur_descriptor.has_value()) {
    return false;
  }
  switch (paint.blend_mode) {
    // Incompatible blend modes:
    case BlendMode::kClear:
    case BlendMode::kSrc:
    case BlendMode::kSrcIn:
    case BlendMode::kDstIn:
    case BlendMode::kSrcOut:
    case BlendMode::kDstATop:
    case BlendMode::kPlus:
    case BlendMode::kModulate:
      return false;
    // Compatible blend modes:
    case BlendMode::kDst:
    case BlendMode::kSrcOver:
    case BlendMode::kDstOver:
    case BlendMode::kDstOut:
    case BlendMode::kSrcATop:
    case BlendMode::kXor:
    case BlendMode::kScreen:
    case BlendMode::kOverlay:
    case BlendMode::kDarken:
    case BlendMode::kLighten:
    case BlendMode::kColorDodge:
    case BlendMode::kColorBurn:
    case BlendMode::kHardLight:
    case BlendMode::kSoftLight:
    case BlendMode::kDifference:
    case BlendMode::kExclusion:
    case BlendMode::kMultiply:
    case BlendMode::kHue:
    case BlendMode::kSaturation:
    case BlendMode::kColor:
    case BlendMode::kLuminosity:
      return true;
  }
}

References impeller::Paint::anti_alias, impeller::Paint::blend_mode, and impeller::Paint::mask_blur_descriptor.

Referenced by DrawCircle(), DrawOval(), DrawRect(), DrawRoundRect(), DrawRoundSuperellipse(), impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST_P().

PreConcat()

void impeller::Canvas::PreConcat

(

const Matrix &

transform

)

Definition at line 360 of file canvas.cc.

                                              {
  transform_stack_.back().transform = transform * GetCurrentTransform();
}

References GetCurrentTransform(), and transform.

Referenced by impeller::DlDispatcherBase::drawShadow().

RequiresReadback()

bool impeller::Canvas::RequiresReadback ( ) const

inline

Definition at line 265 of file canvas.h.

{ return requires_readback_; }

ResetTransform()

void impeller::Canvas::ResetTransform

(

)

Definition at line 364 of file canvas.cc.

                            {
  transform_stack_.back().transform = {};
}

Referenced by impeller::DlDispatcherBase::transformReset().

Restore()

bool impeller::Canvas::Restore

(

)

Definition at line 1781 of file canvas.cc.

                     {
  FML_DCHECK(transform_stack_.size() > 0);
  if (transform_stack_.size() == 1) {
    return false;
  }
 
  // This check is important to make sure we didn't exceed the depth
  // that the clips were rendered at while rendering any of the
  // rendering ops. It is OK for the current depth to equal the
  // outgoing clip depth because that means the clipping would have
  // been successful up through the last rendering op, but it cannot
  // be greater.
  // Also, we bump the current rendering depth to the outgoing clip
  // depth so that future rendering operations are not clipped by
  // any of the pixels set by the expiring clips. It is OK for the
  // estimates used to determine the clip depth in save/saveLayer
  // to be overly conservative, but we need to jump the depth to
  // the clip depth so that the next rendering op will get a
  // larger depth (it will pre-increment the current_depth_ value).
  FML_DCHECK(current_depth_ <= transform_stack_.back().clip_depth)
      << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
  current_depth_ = transform_stack_.back().clip_depth;
 
  if (IsSkipping()) {
    transform_stack_.pop_back();
    return true;
  }
 
  if (transform_stack_.back().rendering_mode ==
          Entity::RenderingMode::kSubpassAppendSnapshotTransform ||
      transform_stack_.back().rendering_mode ==
          Entity::RenderingMode::kSubpassPrependSnapshotTransform) {
    auto lazy_render_pass = std::move(render_passes_.back());
    render_passes_.pop_back();
    // Force the render pass to be constructed if it never was.
    lazy_render_pass.GetInlinePassContext()->GetRenderPass();
 
    SaveLayerState save_layer_state = save_layer_state_.back();
    save_layer_state_.pop_back();
    auto global_pass_position = GetGlobalPassPosition();
 
    std::shared_ptr<Contents> contents = CreateContentsForSubpassTarget(
        renderer_, save_layer_state.paint,                         //
        lazy_render_pass.GetInlinePassContext()->GetTexture(),     //
        Matrix::MakeTranslation(Vector3{-global_pass_position}) *  //
            transform_stack_.back().transform                      //
    );
 
    lazy_render_pass.GetInlinePassContext()->EndPass();
 
    // Round the subpass texture position for pixel alignment with the parent
    // pass render target. By default, we draw subpass textures with nearest
    // sampling, so aligning here is important for avoiding visual nearest
    // sampling errors caused by limited floating point precision when
    // straddling a half pixel boundary.
    Point subpass_texture_position;
    if (transform_stack_.back().did_round_out) {
      // Subpass coverage was rounded out, origin potentially moved "down" by
      // as much as a pixel.
      subpass_texture_position =
          (save_layer_state.coverage.GetOrigin() - global_pass_position)
              .Floor();
    } else {
      // Subpass coverage was truncated. Pick the closest phyiscal pixel.
      subpass_texture_position =
          (save_layer_state.coverage.GetOrigin() - global_pass_position)
              .Round();
    }
 
    Entity element_entity;
    element_entity.SetClipDepth(++current_depth_);
    element_entity.SetContents(std::move(contents));
    element_entity.SetBlendMode(save_layer_state.paint.blend_mode);
    element_entity.SetTransform(
        Matrix::MakeTranslation(Vector3(subpass_texture_position)));
 
    if (element_entity.GetBlendMode() > Entity::kLastPipelineBlendMode) {
      if (renderer_.GetDeviceCapabilities().SupportsFramebufferFetch()) {
        ApplyFramebufferBlend(element_entity);
      } else {
        // End the active pass and flush the buffer before rendering "advanced"
        // blends. Advanced blends work by binding the current render target
        // texture as an input ("destination"), blending with a second texture
        // input ("source"), writing the result to an intermediate texture, and
        // finally copying the data from the intermediate texture back to the
        // render target texture. And so all of the commands that have written
        // to the render target texture so far need to execute before it's bound
        // for blending (otherwise the blend pass will end up executing before
        // all the previous commands in the active pass).
        auto input_texture = FlipBackdrop(GetGlobalPassPosition());
        if (!input_texture) {
          return false;
        }
 
        FilterInput::Vector inputs = {
            FilterInput::Make(input_texture,
                              element_entity.GetTransform().Invert()),
            FilterInput::Make(element_entity.GetContents())};
        auto contents = ColorFilterContents::MakeBlend(
            element_entity.GetBlendMode(), inputs);
        contents->SetCoverageHint(element_entity.GetCoverage());
        element_entity.SetContents(std::move(contents));
        element_entity.SetBlendMode(BlendMode::kSrc);
      }
    }
 
    element_entity.Render(
        renderer_,                                                      //
        *render_passes_.back().GetInlinePassContext()->GetRenderPass()  //
    );
    clip_coverage_stack_.PopSubpass();
    transform_stack_.pop_back();
 
    // We don't need to restore clips if a saveLayer was performed, as the clip
    // state is per render target, and no more rendering operations will be
    // performed as the render target workloaded is completed in the restore.
    return true;
  }
 
  size_t num_clips = transform_stack_.back().num_clips;
  transform_stack_.pop_back();
 
  if (num_clips > 0) {
    EntityPassClipStack::ClipStateResult clip_state_result =
        clip_coverage_stack_.RecordRestore(GetGlobalPassPosition(),
                                           GetClipHeight());
 
    // Clip restores are never required with depth based clipping.
    FML_DCHECK(!clip_state_result.should_render);
    if (clip_state_result.clip_did_change) {
      // We only need to update the pass scissor if the clip state has changed.
      SetClipScissor(
          clip_coverage_stack_.CurrentClipCoverage(),                      //
          *render_passes_.back().GetInlinePassContext()->GetRenderPass(),  //
          GetGlobalPassPosition()                                          //
      );
    }
  }
 
  return true;
}

References impeller::Paint::blend_mode, impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::Canvas::SaveLayerState::coverage, impeller::EntityPassClipStack::CurrentClipCoverage(), FML_DCHECK, impeller::Entity::GetBlendMode(), impeller::Entity::GetContents(), impeller::Entity::GetCoverage(), impeller::ContentContext::GetDeviceCapabilities(), impeller::TRect< T >::GetOrigin(), impeller::Entity::GetTransform(), impeller::Matrix::Invert(), impeller::Entity::kLastPipelineBlendMode, impeller::kSrc, impeller::Entity::kSubpassAppendSnapshotTransform, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeTranslation(), impeller::Canvas::SaveLayerState::paint, impeller::EntityPassClipStack::PopSubpass(), impeller::EntityPassClipStack::RecordRestore(), impeller::Entity::Render(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::EntityPassClipStack::ClipStateResult::should_render, and impeller::Capabilities::SupportsFramebufferFetch().

Referenced by impeller::DlDispatcherBase::drawShadow(), DrawTextFrame(), impeller::DlDispatcherBase::restore(), and RestoreToCount().

RestoreToCount()

void impeller::Canvas::RestoreToCount

(

size_t

count

)

Definition at line 419 of file canvas.cc.

                                        {
  while (GetSaveCount() > count) {
    if (!Restore()) {
      return;
    }
  }
}

References GetSaveCount(), and Restore().

Referenced by impeller::DlDispatcherBase::drawDisplayList().

Rotate()

void impeller::Canvas::Rotate

(

Radians

radians

)

Definition at line 392 of file canvas.cc.

                                   {
  Concat(Matrix::MakeRotationZ(radians));
}

References Concat(), and impeller::Matrix::MakeRotationZ().

Referenced by impeller::DlDispatcherBase::rotate().

Save()

void impeller::Canvas::Save

(

uint32_t

total_content_depth = kMaxDepth

)

Definition at line 1497 of file canvas.cc.

                                              {
  if (IsSkipping()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  auto entry = CanvasStackEntry{};
  entry.transform = transform_stack_.back().transform;
  entry.clip_depth = current_depth_ + total_content_depth;
  entry.distributed_opacity = transform_stack_.back().distributed_opacity;
  FML_DCHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
      << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
      << " after allocating " << total_content_depth;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.rendering_mode = Entity::RenderingMode::kDirect;
  transform_stack_.push_back(entry);
}

References FML_DCHECK, impeller::Entity::kDirect, and impeller::CanvasStackEntry::transform.

Referenced by impeller::DlDispatcherBase::drawDisplayList(), impeller::DlDispatcherBase::drawShadow(), DrawTextFrame(), impeller::DlDispatcherBase::save(), and SaveLayer().

SaveLayer()

void impeller::Canvas::SaveLayer	(	const Paint &	paint,
		std::optional< Rect >	bounds = std::nullopt,
		const flutter::DlImageFilter *	backdrop_filter = nullptr,
		ContentBoundsPromise	bounds_promise = ContentBoundsPromise::kUnknown,
		uint32_t	total_content_depth = kMaxDepth,
		bool	can_distribute_opacity = false,
		std::optional< int64_t >	backdrop_id = std::nullopt
	)

Definition at line 1551 of file canvas.cc.

                                                         {
  TRACE_EVENT0("flutter", "Canvas::saveLayer");
  if (IsSkipping()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  auto maybe_coverage_limit = GetLocalCoverageLimit();
  if (!maybe_coverage_limit.has_value()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
  auto coverage_limit = maybe_coverage_limit.value();
 
  if (can_distribute_opacity && !backdrop_filter &&
      Paint::CanApplyOpacityPeephole(paint) &&
      bounds_promise != ContentBoundsPromise::kMayClipContents) {
    Save(total_content_depth);
    transform_stack_.back().distributed_opacity *= paint.color.alpha;
    return;
  }
 
  std::shared_ptr<FilterContents> filter_contents = paint.WithImageFilter(
      renderer_, Rect(), transform_stack_.back().transform,
      Entity::RenderingMode::kSubpassPrependSnapshotTransform);
 
  std::optional<Rect> maybe_subpass_coverage = ComputeSaveLayerCoverage(
      bounds.value_or(Rect::MakeMaximum()),
      transform_stack_.back().transform,  //
      coverage_limit,                     //
      filter_contents,                    //
      /*flood_output_coverage=*/
      Entity::IsBlendModeDestructive(paint.blend_mode),  //
      /*flood_input_coverage=*/!!backdrop_filter ||
          (paint.color_filter &&
           paint.color_filter->modifies_transparent_black())  //
  );
 
  if (!maybe_subpass_coverage.has_value()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  auto subpass_coverage = maybe_subpass_coverage.value();
 
  // When an image filter is present, clamp to avoid flicking due to nearest
  // sampled image. For other cases, round out to ensure than any geometry is
  // not cut off.
  //
  // See also this bug: https://github.com/flutter/flutter/issues/144213
  //
  // TODO(jonahwilliams): this could still round out for filters that use decal
  // sampling mode.
  ISize subpass_size;
  bool did_round_out = false;
  Point coverage_origin_adjustment = Point{0, 0};
  if (paint.image_filter) {
    subpass_size = ISize(subpass_coverage.GetSize());
  } else {
    did_round_out = true;
    subpass_size =
        static_cast<ISize>(IRect::RoundOut(subpass_coverage).GetSize());
    // If rounding out, adjust the coverage to account for the subpixel shift.
    coverage_origin_adjustment =
        Point(subpass_coverage.GetLeftTop().x -
                  std::floor(subpass_coverage.GetLeftTop().x),
              subpass_coverage.GetLeftTop().y -
                  std::floor(subpass_coverage.GetLeftTop().y));
  }
  if (subpass_size.IsEmpty()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  // When there are scaling filters present, these contents may exceed the
  // maximum texture size. Perform a clamp here, which may cause rendering
  // artifacts.
  subpass_size = subpass_size.Min(renderer_.GetContext()
                                      ->GetCapabilities()
                                      ->GetMaximumRenderPassAttachmentSize());
 
  // Backdrop filter state, ignored if there is no BDF.
  std::shared_ptr<FilterContents> backdrop_filter_contents;
  Point local_position = Point(0, 0);
  if (backdrop_filter) {
    local_position = subpass_coverage.GetOrigin() - GetGlobalPassPosition();
 
    std::shared_ptr<Texture> input_texture;
 
    // If the backdrop ID is not nullopt and there is more than one usage
    // of it in the current scene, cache the backdrop texture and remove it from
    // the current entity pass flip.
    bool will_cache_backdrop_texture = false;
    BackdropData* backdrop_data = nullptr;
    // If we've reached this point, there is at least one backdrop filter. But
    // potentially more if there is a backdrop id. We may conditionally set this
    // to a higher value in the if block below.
    size_t backdrop_count = 1;
    if (backdrop_id.has_value()) {
      std::unordered_map<int64_t, BackdropData>::iterator backdrop_data_it =
          backdrop_data_.find(backdrop_id.value());
      if (backdrop_data_it != backdrop_data_.end()) {
        backdrop_data = &backdrop_data_it->second;
        will_cache_backdrop_texture =
            backdrop_data_it->second.backdrop_count > 1;
        backdrop_count = backdrop_data_it->second.backdrop_count;
      }
    }
 
    if (!will_cache_backdrop_texture || !backdrop_data->texture_slot) {
      backdrop_count_ -= backdrop_count;
 
      // The onscreen texture can be flipped to if:
      // 1. The device supports framebuffer fetch
      // 2. There are no more backdrop filters
      // 3. The current render pass is for the onscreen pass.
      const bool should_use_onscreen =
          renderer_.GetDeviceCapabilities().SupportsFramebufferFetch() &&
          backdrop_count_ == 0 && render_passes_.size() == 1u;
      input_texture = FlipBackdrop(
          GetGlobalPassPosition(),                                //
          /*should_remove_texture=*/will_cache_backdrop_texture,  //
          /*should_use_onscreen=*/should_use_onscreen             //
      );
      if (!input_texture) {
        // Validation failures are logged in FlipBackdrop.
        return;
      }
 
      if (will_cache_backdrop_texture) {
        backdrop_data->texture_slot = input_texture;
      }
    } else {
      input_texture = backdrop_data->texture_slot;
    }
 
    backdrop_filter_contents =
        WrapInput(renderer_, backdrop_filter,
                  FilterInput::Make(std::move(input_texture)));
    backdrop_filter_contents->SetEffectTransform(
        transform_stack_.back().transform.Basis());
    backdrop_filter_contents->SetRenderingMode(
        transform_stack_.back().transform.HasTranslation()
            ? Entity::RenderingMode::kSubpassPrependSnapshotTransform
            : Entity::RenderingMode::kSubpassAppendSnapshotTransform);
 
    if (will_cache_backdrop_texture) {
      FML_DCHECK(backdrop_data);
      // If all filters on the shared backdrop layer are equal, process the
      // layer once.
      if (backdrop_data->all_filters_equal &&
          !backdrop_data->shared_filter_snapshot.has_value()) {
        // TODO(157110): compute minimum input hint.
        backdrop_data->shared_filter_snapshot =
            backdrop_filter_contents->RenderToSnapshot(renderer_, {}, {});
      }
 
      std::optional<Snapshot> maybe_snapshot =
          backdrop_data->shared_filter_snapshot;
      if (maybe_snapshot.has_value()) {
        const Snapshot& snapshot = maybe_snapshot.value();
        std::shared_ptr<TextureContents> contents = TextureContents::MakeRect(
            subpass_coverage.Shift(-GetGlobalPassPosition()));
        auto scaled =
            subpass_coverage.TransformBounds(snapshot.transform.Invert());
        contents->SetTexture(snapshot.texture);
        contents->SetSourceRect(scaled);
        contents->SetSamplerDescriptor(snapshot.sampler_descriptor);
 
        // This backdrop entity sets a depth value as it is written to the newly
        // flipped backdrop and not into a new saveLayer.
        Entity backdrop_entity;
        backdrop_entity.SetContents(std::move(contents));
        backdrop_entity.SetClipDepth(++current_depth_);
        backdrop_entity.SetBlendMode(paint.blend_mode);
 
        backdrop_entity.Render(renderer_, GetCurrentRenderPass());
        Save(0);
        return;
      }
    }
  }
 
  // When applying a save layer, absorb any pending distributed opacity.
  Paint paint_copy = paint;
  paint_copy.color.alpha *= transform_stack_.back().distributed_opacity;
  transform_stack_.back().distributed_opacity = 1.0;
 
  render_passes_.push_back(
      LazyRenderingConfig(renderer_,                                    //
                          CreateRenderTarget(renderer_,                 //
                                             subpass_size,              //
                                             Color::BlackTransparent()  //
                                             )));
  save_layer_state_.push_back(SaveLayerState{
      paint_copy, subpass_coverage.Shift(-coverage_origin_adjustment)});
 
  CanvasStackEntry entry;
  entry.transform = transform_stack_.back().transform;
  entry.clip_depth = current_depth_ + total_content_depth;
  FML_DCHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
      << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
      << " after allocating " << total_content_depth;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.rendering_mode = Entity::RenderingMode::kSubpassAppendSnapshotTransform;
  entry.did_round_out = did_round_out;
  transform_stack_.emplace_back(entry);
 
  // Start non-collapsed subpasses with a fresh clip coverage stack limited by
  // the subpass coverage. This is important because image filters applied to
  // save layers may transform the subpass texture after it's rendered,
  // causing parent clip coverage to get misaligned with the actual area that
  // the subpass will affect in the parent pass.
  clip_coverage_stack_.PushSubpass(subpass_coverage, GetClipHeight());
 
  if (!backdrop_filter_contents) {
    return;
  }
 
  // Render the backdrop entity.
  Entity backdrop_entity;
  backdrop_entity.SetContents(std::move(backdrop_filter_contents));
  backdrop_entity.SetTransform(
      Matrix::MakeTranslation(Vector3(-local_position)));
  backdrop_entity.SetClipDepth(std::numeric_limits<uint32_t>::max());
  backdrop_entity.Render(renderer_, GetCurrentRenderPass());
}

References impeller::BackdropData::all_filters_equal, impeller::Color::alpha, impeller::BackdropData::backdrop_count, impeller::Color::BlackTransparent(), impeller::Paint::blend_mode, impeller::Paint::CanApplyOpacityPeephole(), impeller::CanvasStackEntry::clip_depth, impeller::CanvasStackEntry::clip_height, impeller::Paint::color, impeller::Paint::color_filter, impeller::ComputeSaveLayerCoverage(), impeller::CanvasStackEntry::did_round_out, FML_DCHECK, impeller::ContentContext::GetContext(), impeller::ContentContext::GetDeviceCapabilities(), GetLocalCoverageLimit(), impeller::Paint::image_filter, impeller::Matrix::Invert(), impeller::Entity::IsBlendModeDestructive(), impeller::kMayClipContents, impeller::Entity::kSubpassAppendSnapshotTransform, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TextureContents::MakeRect(), impeller::Matrix::MakeTranslation(), flutter::DlColorFilter::modifies_transparent_black(), impeller::EntityPassClipStack::PushSubpass(), impeller::Entity::Render(), impeller::CanvasStackEntry::rendering_mode, impeller::TRect< T >::RoundOut(), impeller::Snapshot::sampler_descriptor, Save(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::BackdropData::shared_filter_snapshot, subpass_size, impeller::Capabilities::SupportsFramebufferFetch(), impeller::Snapshot::texture, impeller::BackdropData::texture_slot, TRACE_EVENT0, impeller::CanvasStackEntry::transform, impeller::Snapshot::transform, impeller::Paint::WithImageFilter(), and impeller::WrapInput().

Referenced by impeller::DlDispatcherBase::drawDisplayList(), and impeller::DlDispatcherBase::saveLayer().

Scale() [1/2]

void impeller::Canvas::Scale

(

const Vector2 &

scale

)

Definition at line 380 of file canvas.cc.

                                       {
  Concat(Matrix::MakeScale(scale));
}

References Concat(), and impeller::Matrix::MakeScale().

Referenced by impeller::DlDispatcherBase::scale().

Scale() [2/2]

void impeller::Canvas::Scale

(

const Vector3 &

scale

)

Definition at line 384 of file canvas.cc.

                                       {
  Concat(Matrix::MakeScale(scale));
}

References Concat(), and impeller::Matrix::MakeScale().

SetBackdropData()

void impeller::Canvas::SetBackdropData	(	std::unordered_map< int64_t, BackdropData >	backdrop_data,
		size_t	backdrop_count
	)

Update the backdrop data used to group together backdrop filters within the same layer.

Definition at line 2242 of file canvas.cc.

                           {
  backdrop_data_ = std::move(backdrop_data);
  backdrop_count_ = backdrop_count;
}

Referenced by impeller::CanvasDlDispatcher::SetBackdropData().

Skew()

void impeller::Canvas::Skew	(	Scalar	sx,
		Scalar	sy
	)

Definition at line 388 of file canvas.cc.

                                      {
  Concat(Matrix::MakeSkew(sx, sy));
}

References Concat(), and impeller::Matrix::MakeSkew().

Referenced by impeller::DlDispatcherBase::skew().

SupportsBlitToOnscreen()

bool impeller::Canvas::SupportsBlitToOnscreen

(

)

const

Definition at line 2365 of file canvas.cc.

                                          {
  return renderer_.GetContext()
             ->GetCapabilities()
             ->SupportsTextureToTextureBlits() &&
         renderer_.GetContext()->GetBackendType() ==
             Context::BackendType::kMetal;
}

Transform()

void impeller::Canvas::Transform

(

const Matrix &

transform

)

Definition at line 368 of file canvas.cc.

                                              {
  Concat(transform);
}

References Concat(), and transform.

Referenced by impeller::DlDispatcherBase::transformFullPerspective(), and impeller::DlDispatcherBase::transformReset().

Translate()

void impeller::Canvas::Translate

(

const Vector3 &

offset

)

Definition at line 376 of file canvas.cc.

                                            {
  Concat(Matrix::MakeTranslation(offset));
}

References Concat(), and impeller::Matrix::MakeTranslation().

Referenced by DrawTextFrame(), and impeller::DlDispatcherBase::translate().

Member Data Documentation

kMaxDepth

constexpr uint32_t impeller::Canvas::kMaxDepth = 1 << 24

staticconstexpr

Definition at line 121 of file canvas.h.

---

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

• impeller/display_list/canvas.h
• impeller/display_list/canvas.cc
• lib/ui/painting/canvas.cc