impeller::Canvas Class Reference

#include <canvas.h>

Classes
struct	DebugOptions

Public Member Functions
	Canvas ()
	Canvas (Rect cull_rect)
	Canvas (IRect cull_rect)
	~Canvas ()
void	Save ()
void	SaveLayer (const Paint &paint, std::optional< Rect > bounds=std::nullopt, const std::shared_ptr< ImageFilter > &backdrop_filter=nullptr)
bool	Restore ()
size_t	GetSaveCount () const
void	RestoreToCount (size_t count)
const Matrix &	GetCurrentTransform () const
const std::optional< Rect >	GetCurrentLocalCullingBounds () 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 (Path path, const Paint &paint)
void	DrawPaint (const Paint &paint)
void	DrawLine (const Point &p0, const Point &p1, const Paint &paint)
void	DrawRect (const Rect &rect, const Paint &paint)
void	DrawOval (const Rect &rect, const Paint &paint)
void	DrawRRect (const Rect &rect, const Size &corner_radii, const Paint &paint)
void	DrawCircle (const Point &center, Scalar radius, const Paint &paint)
void	DrawPoints (std::vector< Point > points, Scalar radius, const Paint &paint, PointStyle point_style)
void	DrawImage (const std::shared_ptr< Image > &image, Point offset, const Paint &paint, SamplerDescriptor sampler={})
void	DrawImageRect (const std::shared_ptr< Image > &image, Rect source, Rect dest, const Paint &paint, SamplerDescriptor sampler={})
void	ClipPath (Path path, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRect (const Rect &rect, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipOval (const Rect &bounds, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRRect (const Rect &rect, const Size &corner_radii, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	DrawPicture (const Picture &picture)
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< Image > &atlas, std::vector< Matrix > transforms, std::vector< Rect > texture_coordinates, std::vector< Color > colors, BlendMode blend_mode, SamplerDescriptor sampler, std::optional< Rect > cull_rect, const Paint &paint)
Picture	EndRecordingAsPicture ()

Public Attributes
struct impeller::Canvas::DebugOptions	debug_options

Detailed Description

Definition at line 48 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/3]

impeller::Canvas::Canvas

(

)

Definition at line 102 of file canvas.cc.

               {
  Initialize(std::nullopt);
}

Canvas() [2/3]

impeller::Canvas::Canvas ( Rect  cull_rect )

explicit

Definition at line 106 of file canvas.cc.

                             {
  Initialize(cull_rect);
}

Canvas() [3/3]

impeller::Canvas::Canvas ( IRect  cull_rect )

explicit

Definition at line 110 of file canvas.cc.

                              {
  Initialize(Rect::MakeLTRB(cull_rect.GetLeft(), cull_rect.GetTop(),
                            cull_rect.GetRight(), cull_rect.GetBottom()));
}

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

~Canvas()

impeller::Canvas::~Canvas ( )

default

Member Function Documentation

ClipOval()

void impeller::Canvas::ClipOval	(	const Rect &	bounds,
		Entity::ClipOperation	clip_op = Entity::ClipOperation::kIntersect
	)

Definition at line 450 of file canvas.cc.

                                                                     {
  auto geometry = Geometry::MakeOval(bounds);
  auto& cull_rect = transform_stack_.back().cull_rect;
  if (clip_op == Entity::ClipOperation::kIntersect &&                      //
      cull_rect.has_value() &&                                             //
      geometry->CoversArea(transform_stack_.back().transform, *cull_rect)  //
  ) {
    return;  // This clip will do nothing, so skip it.
  }
 
  ClipGeometry(geometry, clip_op);
  switch (clip_op) {
    case Entity::ClipOperation::kIntersect:
      IntersectCulling(bounds);
      break;
    case Entity::ClipOperation::kDifference:
      break;
  }
}

References impeller::Entity::kDifference, impeller::Entity::kIntersect, and impeller::Geometry::MakeOval().

Referenced by impeller::DlDispatcher::clipPath(), impeller::DlDispatcher::clipRRect(), and impeller::testing::TEST_P().

ClipPath()

void impeller::Canvas::ClipPath	(	Path	path,
		Entity::ClipOperation	clip_op = Entity::ClipOperation::kIntersect
	)

Definition at line 419 of file canvas.cc.

                                                            {
  auto bounds = path.GetBoundingBox();
  ClipGeometry(Geometry::MakeFillPath(std::move(path)), clip_op);
  if (clip_op == Entity::ClipOperation::kIntersect) {
    if (bounds.has_value()) {
      IntersectCulling(bounds.value());
    }
  }
}

References impeller::Path::GetBoundingBox(), impeller::Entity::kIntersect, and impeller::Geometry::MakeFillPath().

Referenced by impeller::DlDispatcher::clipPath(), impeller::DlDispatcher::clipRRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

ClipRect()

void impeller::Canvas::ClipRect	(	const Rect &	rect,
		Entity::ClipOperation	clip_op = Entity::ClipOperation::kIntersect
	)

Definition at line 429 of file canvas.cc.

                                                                   {
  auto geometry = Geometry::MakeRect(rect);
  auto& cull_rect = transform_stack_.back().cull_rect;
  if (clip_op == Entity::ClipOperation::kIntersect &&                      //
      cull_rect.has_value() &&                                             //
      geometry->CoversArea(transform_stack_.back().transform, *cull_rect)  //
  ) {
    return;  // This clip will do nothing, so skip it.
  }
 
  ClipGeometry(geometry, clip_op);
  switch (clip_op) {
    case Entity::ClipOperation::kIntersect:
      IntersectCulling(rect);
      break;
    case Entity::ClipOperation::kDifference:
      SubtractCulling(rect);
      break;
  }
}

References impeller::Entity::kDifference, impeller::Entity::kIntersect, and impeller::Geometry::MakeRect().

Referenced by impeller::DlDispatcher::clipPath(), impeller::DlDispatcher::clipRect(), impeller::DlDispatcher::clipRRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

ClipRRect()

void impeller::Canvas::ClipRRect	(	const Rect &	rect,
		const Size &	corner_radii,
		Entity::ClipOperation	clip_op = Entity::ClipOperation::kIntersect
	)

Definition at line 470 of file canvas.cc.

                                                    {
  // Does the rounded rect have a flat part on the top/bottom or left/right?
  bool flat_on_TB = corner_radii.width * 2 < rect.GetWidth();
  bool flat_on_LR = corner_radii.height * 2 < rect.GetHeight();
  auto geometry = Geometry::MakeRoundRect(rect, corner_radii);
  auto& cull_rect = transform_stack_.back().cull_rect;
  if (clip_op == Entity::ClipOperation::kIntersect &&                      //
      cull_rect.has_value() &&                                             //
      geometry->CoversArea(transform_stack_.back().transform, *cull_rect)  //
  ) {
    return;  // This clip will do nothing, so skip it.
  }
 
  ClipGeometry(geometry, clip_op);
  switch (clip_op) {
    case Entity::ClipOperation::kIntersect:
      IntersectCulling(rect);
      break;
    case Entity::ClipOperation::kDifference:
      if (corner_radii.IsEmpty()) {
        SubtractCulling(rect);
      } else {
        // We subtract the inner "tall" and "wide" rectangle pieces
        // that fit inside the corners which cover the greatest area
        // without involving the curved corners
        // Since this is a subtract operation, we can subtract each
        // rectangle piece individually without fear of interference.
        if (flat_on_TB) {
          SubtractCulling(rect.Expand(Size{-corner_radii.width, 0.0}));
        }
        if (flat_on_LR) {
          SubtractCulling(rect.Expand(Size{0.0, -corner_radii.height}));
        }
      }
      break;
  }
}

References impeller::TRect< T >::Expand(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TSize< T >::height, impeller::TSize< T >::IsEmpty(), impeller::Entity::kDifference, impeller::Entity::kIntersect, impeller::Geometry::MakeRoundRect(), and impeller::TSize< T >::width.

Referenced by impeller::DlDispatcher::clipPath(), impeller::DlDispatcher::clipRRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

Concat()

void impeller::Canvas::Concat

(

const Matrix &

transform

)

Definition at line 189 of file canvas.cc.

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

References GetCurrentTransform().

Referenced by Rotate(), Scale(), Skew(), impeller::testing::TEST_P(), Transform(), and Translate().

DrawAtlas()

void impeller::Canvas::DrawAtlas	(	const std::shared_ptr< Image > &	atlas,
		std::vector< Matrix >	transforms,
		std::vector< Rect >	texture_coordinates,
		std::vector< Color >	colors,
		BlendMode	blend_mode,
		SamplerDescriptor	sampler,
		std::optional< Rect >	cull_rect,
		const Paint &	paint
	)

Definition at line 806 of file canvas.cc.

                                           {
  if (!atlas) {
    return;
  }
 
  std::shared_ptr<AtlasContents> contents = std::make_shared<AtlasContents>();
  contents->SetColors(std::move(colors));
  contents->SetTransforms(std::move(transforms));
  contents->SetTextureCoordinates(std::move(texture_coordinates));
  contents->SetTexture(atlas->GetTexture());
  contents->SetSamplerDescriptor(std::move(sampler));
  contents->SetBlendMode(blend_mode);
  contents->SetCullRect(cull_rect);
  contents->SetAlpha(paint.color.alpha);
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(contents));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

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

Referenced by impeller::DlDispatcher::drawAtlas(), and impeller::testing::TEST_P().

DrawCircle()

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

Definition at line 395 of file canvas.cc.

                                            {
  Size half_size(radius, radius);
  if (AttemptDrawBlurredRRect(
          Rect::MakeOriginSize(center - half_size, half_size * 2),
          {radius, radius}, paint)) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  auto geometry =
      paint.style == Paint::Style::kStroke
          ? Geometry::MakeStrokedCircle(center, radius, paint.stroke_width)
          : Geometry::MakeCircle(center, radius);
  entity.SetContents(
      CreateContentsForGeometryWithFilters(paint, std::move(geometry)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Paint::kStroke, impeller::Geometry::MakeCircle(), impeller::TRect< Scalar >::MakeOriginSize(), impeller::Geometry::MakeStrokedCircle(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Paint::stroke_width, and impeller::Paint::style.

Referenced by impeller::DlDispatcher::drawCircle(), DrawOval(), and impeller::testing::TEST_P().

DrawImage()

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

Definition at line 612 of file canvas.cc.

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

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

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

DrawImageRect()

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

Definition at line 626 of file canvas.cc.

                                                      {
  if (!image || source.IsEmpty() || dest.IsEmpty()) {
    return;
  }
 
  auto size = image->GetSize();
 
  if (size.IsEmpty()) {
    return;
  }
 
  auto contents = TextureContents::MakeRect(dest);
  contents->SetTexture(image->GetTexture());
  contents->SetSourceRect(source);
  contents->SetSamplerDescriptor(std::move(sampler));
  contents->SetOpacity(paint.color.alpha);
  contents->SetDeferApplyingOpacity(paint.HasColorFilter());
 
  Entity entity;
  entity.SetBlendMode(paint.blend_mode);
  entity.SetClipDepth(GetClipDepth());
  entity.SetContents(paint.WithFilters(contents));
  entity.SetTransform(GetCurrentTransform());
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransform(), impeller::Paint::HasColorFilter(), impeller::TRect< T >::IsEmpty(), impeller::TextureContents::MakeRect(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Paint::WithFilters().

Referenced by DrawImage(), impeller::DlDispatcher::drawImageRect(), impeller::NinePatchConverter::DrawNinePatch(), and impeller::testing::TEST_P().

DrawLine()

void impeller::Canvas::DrawLine	(	const Point &	p0,
		const Point &	p1,
		const Paint &	paint
	)

Definition at line 310 of file canvas.cc.

                                                                          {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(CreateContentsForGeometryWithFilters(
      paint, Geometry::MakeLine(p0, p1, paint.stroke_width, paint.stroke_cap)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Geometry::MakeLine(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Paint::stroke_cap, and impeller::Paint::stroke_width.

Referenced by impeller::DlDispatcher::drawLine(), impeller::DlDispatcher::drawPoints(), and impeller::testing::TEST_P().

DrawOval()

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

Definition at line 341 of file canvas.cc.

                                                          {
  if (rect.IsSquare()) {
    // Circles have slightly less overhead and can do stroking
    DrawCircle(rect.GetCenter(), rect.GetWidth() * 0.5f, paint);
    return;
  }
 
  if (paint.style == Paint::Style::kStroke) {
    // No stroked ellipses yet
    DrawPath(PathBuilder{}.AddOval(rect).TakePath(), paint);
    return;
  }
 
  if (AttemptDrawBlurredRRect(rect, rect.GetSize() * 0.5f, paint)) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(
      CreateContentsForGeometryWithFilters(paint, Geometry::MakeOval(rect)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::PathBuilder::AddOval(), impeller::Paint::blend_mode, DrawCircle(), DrawPath(), impeller::TRect< T >::GetCenter(), GetCurrentTransform(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::IsSquare(), impeller::Paint::kStroke, impeller::Geometry::MakeOval(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Paint::style.

Referenced by impeller::DlDispatcher::drawOval(), and impeller::testing::TEST_P().

DrawPaint()

void impeller::Canvas::DrawPaint

(

const Paint &

paint

)

Definition at line 260 of file canvas.cc.

                                         {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(CreateCoverContentsWithFilters(paint));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

Referenced by impeller::testing::BlendModeTest(), impeller::DlDispatcher::drawColor(), impeller::DlDispatcher::drawPaint(), and impeller::testing::TEST_P().

DrawPath()

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

Definition at line 250 of file canvas.cc.

                                                   {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(CreatePathContentsWithFilters(paint, std::move(path)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

Referenced by impeller::DlDispatcher::drawArc(), impeller::DlDispatcher::drawDRRect(), DrawOval(), DrawRect(), DrawRRect(), impeller::DlDispatcher::drawRRect(), and impeller::testing::TEST_P().

DrawPicture()

void impeller::Canvas::DrawPicture

(

const Picture &

picture

)

Definition at line 583 of file canvas.cc.

                                               {
  if (!picture.pass) {
    return;
  }
 
  // Clone the base pass and account for the CTM updates.
  auto pass = picture.pass->Clone();
 
  pass->IterateAllElements([&](auto& element) -> bool {
    if (auto entity = std::get_if<Entity>(&element)) {
      entity->IncrementStencilDepth(GetClipDepth());
      entity->SetTransform(GetCurrentTransform() * entity->GetTransform());
      return true;
    }
 
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      subpass->get()->SetClipDepth(subpass->get()->GetClipDepth() +
                                   GetClipDepth());
      return true;
    }
 
    FML_UNREACHABLE();
  });
 
  GetCurrentPass().AddSubpassInline(std::move(pass));
 
  RestoreClip();
}

References impeller::EntityPass::AddSubpassInline(), GetCurrentTransform(), and impeller::Picture::pass.

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

DrawPoints()

void impeller::Canvas::DrawPoints	(	std::vector< Point >	points,
		Scalar	radius,
		const Paint &	paint,
		PointStyle	point_style
	)

Definition at line 563 of file canvas.cc.

                                                {
  if (radius <= 0) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(CreateContentsForGeometryWithFilters(
      paint,
      Geometry::MakePointField(std::move(points), radius,
                               /*round=*/point_style == PointStyle::kRound)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, GetCurrentTransform(), impeller::kRound, impeller::Geometry::MakePointField(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

Referenced by impeller::DlDispatcher::drawPoints(), and impeller::testing::TEST_P().

DrawRect()

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

Definition at line 321 of file canvas.cc.

                                                          {
  if (paint.style == Paint::Style::kStroke) {
    DrawPath(PathBuilder{}.AddRect(rect).TakePath(), paint);
    return;
  }
 
  if (AttemptDrawBlurredRRect(rect, {}, paint)) {
    return;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(
      CreateContentsForGeometryWithFilters(paint, Geometry::MakeRect(rect)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::PathBuilder::AddRect(), impeller::Paint::blend_mode, DrawPath(), GetCurrentTransform(), impeller::Paint::kStroke, impeller::Geometry::MakeRect(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Paint::style.

Referenced by impeller::testing::CanRenderConicalGradientWithDithering(), impeller::testing::CanRenderLinearGradientWithDithering(), impeller::testing::CanRenderRadialGradientWithDithering(), impeller::testing::CanRenderSweepGradientWithDithering(), impeller::DlDispatcher::drawRect(), impeller::testing::TEST_F(), and impeller::testing::TEST_P().

DrawRRect()

void impeller::Canvas::DrawRRect	(	const Rect &	rect,
		const Size &	corner_radii,
		const Paint &	paint
	)

Definition at line 368 of file canvas.cc.

                                           {
  if (AttemptDrawBlurredRRect(rect, corner_radii, paint)) {
    return;
  }
 
  if (paint.style == Paint::Style::kFill) {
    Entity entity;
    entity.SetTransform(GetCurrentTransform());
    entity.SetClipDepth(GetClipDepth());
    entity.SetBlendMode(paint.blend_mode);
    entity.SetContents(CreateContentsForGeometryWithFilters(
        paint, Geometry::MakeRoundRect(rect, corner_radii)));
 
    GetCurrentPass().AddEntity(std::move(entity));
    return;
  }
 
  auto path = PathBuilder{}
                  .SetConvexity(Convexity::kConvex)
                  .AddRoundedRect(rect, corner_radii)
                  .SetBounds(rect)
                  .TakePath();
  DrawPath(std::move(path), paint);
}

References impeller::EntityPass::AddEntity(), impeller::PathBuilder::AddRoundedRect(), impeller::Paint::blend_mode, DrawPath(), GetCurrentTransform(), impeller::kConvex, impeller::Paint::kFill, impeller::Geometry::MakeRoundRect(), impeller::Entity::SetBlendMode(), impeller::PathBuilder::SetBounds(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::PathBuilder::SetConvexity(), impeller::Entity::SetTransform(), impeller::Paint::style, and impeller::PathBuilder::TakePath().

Referenced by impeller::DlDispatcher::drawRRect(), 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 702 of file canvas.cc.

                                               {
  Entity entity;
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
 
  auto text_contents = std::make_shared<TextContents>();
  text_contents->SetTextFrame(text_frame);
  text_contents->SetColor(paint.color);
  text_contents->SetForceTextColor(paint.mask_blur_descriptor.has_value());
 
  entity.SetTransform(GetCurrentTransform() *
                      Matrix::MakeTranslation(position));
 
  // TODO(bdero): This mask blur application is a hack. It will always wind up
  //              doing a gaussian blur that affects the color source itself
  //              instead of just the mask. The color filter text support
  //              needs to be reworked in order to interact correctly with
  //              mask filters.
  //              https://github.com/flutter/flutter/issues/133297
  entity.SetContents(
      paint.WithFilters(paint.WithMaskBlur(std::move(text_contents), true)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransform(), impeller::Matrix::MakeTranslation(), impeller::Paint::mask_blur_descriptor, impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Paint::WithFilters(), and impeller::Paint::WithMaskBlur().

Referenced by impeller::DlDispatcher::drawTextFrame(), and impeller::testing::TEST_P().

DrawVertices()

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

Definition at line 746 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.GetType() == ColorSource::Type::kColor) {
    blend_mode = BlendMode::kDestination;
  }
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetClipDepth(GetClipDepth());
  entity.SetBlendMode(paint.blend_mode);
 
  // If there are no vertex color or texture coordinates. Or if there
  // are vertex coordinates then only if the contents are an image.
  if (UseColorSourceContents(vertices, paint)) {
    entity.SetContents(CreateContentsForGeometryWithFilters(paint, vertices));
    GetCurrentPass().AddEntity(std::move(entity));
    return;
  }
 
  auto src_paint = paint;
  src_paint.color = paint.color.WithAlpha(1.0);
 
  std::shared_ptr<Contents> src_contents =
      src_paint.CreateContentsForGeometry(vertices);
  if (vertices->HasTextureCoordinates()) {
    // 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());
      src_coverage =
          // Covered by FML_CHECK.
          // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
          vertices->GetTextureCoordinateCoverge().value_or(cvg.value());
    }
    src_contents =
        src_paint.CreateContentsForGeometry(Geometry::MakeRect(src_coverage));
  }
 
  auto contents = std::make_shared<VerticesContents>();
  contents->SetAlpha(paint.color.alpha);
  contents->SetBlendMode(blend_mode);
  contents->SetGeometry(vertices);
  contents->SetSourceContents(std::move(src_contents));
  entity.SetContents(paint.WithFilters(std::move(contents)));
 
  GetCurrentPass().AddEntity(std::move(entity));
}

References impeller::EntityPass::AddEntity(), impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_source, GetCurrentTransform(), impeller::ColorSource::GetType(), impeller::ColorSource::kColor, impeller::kDestination, impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::UseColorSourceContents(), impeller::Color::WithAlpha(), and impeller::Paint::WithFilters().

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

EndRecordingAsPicture()

Picture impeller::Canvas::EndRecordingAsPicture

(

)

Definition at line 657 of file canvas.cc.

                                      {
  Picture picture;
  picture.pass = std::move(base_pass_);
 
  Reset();
  Initialize(initial_cull_rect_);
 
  return picture;
}

References impeller::Picture::pass.

Referenced by impeller::testing::CanRenderConicalGradientWithDithering(), impeller::testing::CanRenderLinearGradientWithDithering(), impeller::testing::CanRenderRadialGradientWithDithering(), impeller::testing::CanRenderSweepGradientWithDithering(), impeller::DlDispatcher::EndRecordingAsPicture(), impeller::testing::TEST_F(), and impeller::testing::TEST_P().

GetCurrentLocalCullingBounds()

const std::optional< Rect > impeller::Canvas::GetCurrentLocalCullingBounds

(

)

const

Definition at line 209 of file canvas.cc.

                                                                   {
  auto cull_rect = transform_stack_.back().cull_rect;
  if (cull_rect.has_value()) {
    Matrix inverse = transform_stack_.back().transform.Invert();
    cull_rect = cull_rect.value().TransformBounds(inverse);
  }
  return cull_rect;
}

Referenced by impeller::DlDispatcher::drawDisplayList(), and impeller::testing::TEST().

GetCurrentTransform()

const Matrix & impeller::Canvas::GetCurrentTransform

(

)

const

Definition at line 205 of file canvas.cc.

                                                {
  return transform_stack_.back().transform;
}

Referenced by Concat(), DrawAtlas(), DrawCircle(), impeller::DlDispatcher::drawDisplayList(), DrawImageRect(), DrawLine(), DrawOval(), DrawPaint(), DrawPath(), DrawPicture(), DrawPoints(), DrawRect(), DrawRRect(), impeller::DlDispatcher::drawShadow(), DrawTextFrame(), DrawVertices(), PreConcat(), and impeller::testing::TEST_P().

GetSaveCount()

size_t impeller::Canvas::GetSaveCount

(

)

const

Definition at line 238 of file canvas.cc.

                                  {
  return transform_stack_.size();
}

Referenced by impeller::DlDispatcher::drawDisplayList(), RestoreToCount(), and impeller::testing::TEST_P().

PreConcat()

void impeller::Canvas::PreConcat

(

const Matrix &

transform

)

Definition at line 193 of file canvas.cc.

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

References GetCurrentTransform().

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

ResetTransform()

void impeller::Canvas::ResetTransform

(

)

Definition at line 197 of file canvas.cc.

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

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

Restore()

bool impeller::Canvas::Restore

(

)

Definition at line 168 of file canvas.cc.

                     {
  FML_DCHECK(transform_stack_.size() > 0);
  if (transform_stack_.size() == 1) {
    return false;
  }
  if (transform_stack_.back().rendering_mode ==
      Entity::RenderingMode::kSubpass) {
    current_pass_ = GetCurrentPass().GetSuperpass();
    FML_DCHECK(current_pass_);
  }
 
  bool contains_clips = transform_stack_.back().contains_clips;
  transform_stack_.pop_back();
 
  if (contains_clips) {
    RestoreClip();
  }
 
  return true;
}

References impeller::EntityPass::GetSuperpass(), and impeller::Entity::kSubpass.

Referenced by impeller::DlDispatcher::drawShadow(), impeller::DlDispatcher::restore(), RestoreToCount(), impeller::testing::TEST(), and impeller::testing::TEST_P().

RestoreToCount()

void impeller::Canvas::RestoreToCount

(

size_t

count

)

Definition at line 242 of file canvas.cc.

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

References GetSaveCount(), and Restore().

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

Rotate()

void impeller::Canvas::Rotate

(

Radians

radians

)

Definition at line 234 of file canvas.cc.

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

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

Referenced by impeller::DlDispatcher::rotate(), and impeller::testing::TEST_P().

Save()

void impeller::Canvas::Save

(

)

Definition at line 132 of file canvas.cc.

                  {
  Save(false);
}

Referenced by impeller::DlDispatcher::drawDisplayList(), impeller::DlDispatcher::drawShadow(), impeller::DlDispatcher::save(), SaveLayer(), impeller::testing::TEST(), and impeller::testing::TEST_P().

SaveLayer()

void impeller::Canvas::SaveLayer	(	const Paint &	paint,
		std::optional< Rect >	bounds = std::nullopt,
		const std::shared_ptr< ImageFilter > &	backdrop_filter = nullptr
	)

Definition at line 676 of file canvas.cc.

                                                                          {
  TRACE_EVENT0("flutter", "Canvas::saveLayer");
  Save(true, paint.blend_mode, backdrop_filter);
 
  // The DisplayList bounds/rtree doesn't account for filters applied to parent
  // layers, and so sub-DisplayLists are getting culled as if no filters are
  // applied.
  // See also: https://github.com/flutter/flutter/issues/139294
  if (paint.image_filter) {
    transform_stack_.back().cull_rect = std::nullopt;
  }
 
  auto& new_layer_pass = GetCurrentPass();
  new_layer_pass.SetBoundsLimit(bounds);
 
  // Only apply opacity peephole on default blending.
  if (paint.blend_mode == BlendMode::kSourceOver) {
    new_layer_pass.SetDelegate(
        std::make_shared<OpacityPeepholePassDelegate>(paint));
  } else {
    new_layer_pass.SetDelegate(std::make_shared<PaintPassDelegate>(paint));
  }
}

References impeller::Paint::blend_mode, impeller::Paint::image_filter, impeller::kSourceOver, and Save().

Referenced by impeller::DlDispatcher::drawDisplayList(), impeller::DlDispatcher::saveLayer(), impeller::testing::TEST(), and impeller::testing::TEST_P().

Scale() [1/2]

void impeller::Canvas::Scale

(

const Vector2 &

scale

)

Definition at line 222 of file canvas.cc.

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

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

Referenced by impeller::testing::CanRenderConicalGradientWithDithering(), impeller::testing::CanRenderSweepGradientWithDithering(), impeller::DlDispatcher::scale(), impeller::testing::TEST(), and impeller::testing::TEST_P().

Scale() [2/2]

void impeller::Canvas::Scale

(

const Vector3 &

scale

)

Definition at line 226 of file canvas.cc.

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

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

Skew()

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

Definition at line 230 of file canvas.cc.

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

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

Referenced by impeller::DlDispatcher::skew(), and impeller::testing::TEST_P().

Transform()

void impeller::Canvas::Transform

(

const Matrix &

transform

)

Definition at line 201 of file canvas.cc.

                                              {
  Concat(transform);
}

References Concat().

Referenced by impeller::testing::TEST_P(), impeller::DlDispatcher::transformFullPerspective(), and impeller::DlDispatcher::transformReset().

Translate()

void impeller::Canvas::Translate

(

const Vector3 &

offset

)

Definition at line 218 of file canvas.cc.

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

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

Referenced by impeller::testing::CanRenderConicalGradientWithDithering(), impeller::testing::CanRenderLinearGradientWithDithering(), impeller::testing::CanRenderRadialGradientWithDithering(), impeller::testing::CanRenderSweepGradientWithDithering(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::DlDispatcher::translate().

Member Data Documentation

debug_options

struct impeller::Canvas::DebugOptions impeller::Canvas::debug_options

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

---

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

• impeller/aiks/canvas.h
• impeller/aiks/canvas.cc