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 &	GetCurrentTransformation () const
const std::optional< Rect >	GetCurrentLocalCullingBounds () const
void	ResetTransform ()
void	Transform (const Matrix &xformation)
void	Concat (const Matrix &xformation)
void	PreConcat (const Matrix &xformation)
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 Path &path, const Paint &paint)
void	DrawPaint (const Paint &paint)
void	DrawRect (Rect rect, const Paint &paint)
void	DrawRRect (Rect rect, Scalar corner_radius, const Paint &paint)
void	DrawCircle (Point center, Scalar radius, const Paint &paint)
void	DrawPoints (std::vector< Point >, 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 (const Path &path, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRect (const Rect &rect, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRRect (const Rect &rect, Scalar corner_radius, 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 50 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/3]

impeller::Canvas::Canvas

(

)

Definition at line 25 of file canvas.cc.

               {
  Initialize(std::nullopt);
}

Canvas() [2/3]

impeller::Canvas::Canvas ( Rect  cull_rect )

explicit

Definition at line 29 of file canvas.cc.

                             {
  Initialize(cull_rect);
}

Canvas() [3/3]

impeller::Canvas::Canvas ( IRect  cull_rect )

explicit

Definition at line 33 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

ClipPath()

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

Definition at line 284 of file canvas.cc.

                                                                   {
  ClipGeometry(Geometry::MakeFillPath(path), clip_op);
  if (clip_op == Entity::ClipOperation::kIntersect) {
    auto bounds = path.GetBoundingBox();
    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 294 of file canvas.cc.

                                                                   {
  auto geometry = Geometry::MakeRect(rect);
  auto& cull_rect = xformation_stack_.back().cull_rect;
  if (clip_op == Entity::ClipOperation::kIntersect &&                        //
      cull_rect.has_value() &&                                               //
      geometry->CoversArea(xformation_stack_.back().xformation, *cull_rect)  //
  ) {
    return;  // This clip will do nothing, so skip it.
  }
 
  ClipGeometry(std::move(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::clipRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

ClipRRect()

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

Definition at line 315 of file canvas.cc.

                                                    {
  auto path = PathBuilder{}
                  .SetConvexity(Convexity::kConvex)
                  .AddRoundedRect(rect, corner_radius)
                  .TakePath();
 
  std::optional<Rect> inner_rect = (corner_radius * 2 < rect.size.width &&
                                    corner_radius * 2 < rect.size.height)
                                       ? rect.Expand(-corner_radius)
                                       : std::make_optional<Rect>();
  auto geometry = Geometry::MakeFillPath(path, inner_rect);
  auto& cull_rect = xformation_stack_.back().cull_rect;
  if (clip_op == Entity::ClipOperation::kIntersect &&                        //
      cull_rect.has_value() &&                                               //
      geometry->CoversArea(xformation_stack_.back().xformation, *cull_rect)  //
  ) {
    return;  // This clip will do nothing, so skip it.
  }
 
  ClipGeometry(std::move(geometry), clip_op);
  switch (clip_op) {
    case Entity::ClipOperation::kIntersect:
      IntersectCulling(rect);
      break;
    case Entity::ClipOperation::kDifference:
      if (corner_radius <= 0) {
        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 (corner_radius * 2 < rect.size.width) {
          SubtractCulling(Rect::MakeLTRB(
              rect.GetLeft() + corner_radius, rect.GetTop(),
              rect.GetRight() - corner_radius, rect.GetBottom()));
        }
        if (corner_radius * 2 < rect.size.height) {
          SubtractCulling(Rect::MakeLTRB(
              rect.GetLeft(), rect.GetTop() + corner_radius,  //
              rect.GetRight(), rect.GetBottom() - corner_radius));
        }
      }
      break;
  }
}

References impeller::PathBuilder::AddRoundedRect(), impeller::TRect< T >::Expand(), impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TSize< T >::height, impeller::kConvex, impeller::Entity::kDifference, impeller::Entity::kIntersect, impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), impeller::PathBuilder::SetConvexity(), impeller::TRect< T >::size, impeller::PathBuilder::TakePath(), and impeller::TSize< T >::width.

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

Concat()

void impeller::Canvas::Concat

(

const Matrix &

xformation

)

Definition at line 112 of file canvas.cc.

                                            {
  xformation_stack_.back().xformation = GetCurrentTransformation() * xformation;
}

References GetCurrentTransformation().

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 653 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.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(contents));
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransformation(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), and impeller::Paint::WithFilters().

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

DrawCircle()

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

Definition at line 271 of file canvas.cc.

                                                                       {
  Size half_size(radius, radius);
  if (AttemptDrawBlurredRRect(Rect(center - half_size, half_size * 2), radius,
                              paint)) {
    return;
  }
  auto circle_path = PathBuilder{}
                         .AddCircle(center, radius)
                         .SetConvexity(Convexity::kConvex)
                         .TakePath();
  DrawPath(circle_path, paint);
}

References impeller::PathBuilder::AddCircle(), DrawPath(), impeller::kConvex, impeller::PathBuilder::SetConvexity(), and impeller::PathBuilder::TakePath().

Referenced by impeller::DlDispatcher::drawCircle(), impeller::DlDispatcher::drawOval(), impeller::DlDispatcher::drawPath(), impeller::DlDispatcher::drawShadow(), 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 467 of file canvas.cc.

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

References DrawImageRect(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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 482 of file canvas.cc.

                                                      {
  if (!image || source.size.IsEmpty() || dest.size.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.SetStencilDepth(GetStencilDepth());
  entity.SetContents(paint.WithFilters(contents));
  entity.SetTransformation(GetCurrentTransformation());
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransformation(), impeller::Paint::HasColorFilter(), impeller::TSize< T >::IsEmpty(), impeller::TextureContents::MakeRect(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), impeller::TRect< T >::size, and impeller::Paint::WithFilters().

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

DrawPaint()

void impeller::Canvas::DrawPaint

(

const Paint &

paint

)

Definition at line 183 of file canvas.cc.

                                         {
  Entity entity;
  entity.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.CreateContentsForEntity({}, true));
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, impeller::Paint::CreateContentsForEntity(), GetCurrentTransformation(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), and impeller::Entity::SetTransformation().

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

DrawPath()

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

Definition at line 173 of file canvas.cc.

                                                          {
  Entity entity;
  entity.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(paint.CreateContentsForEntity(path)));
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, impeller::Paint::CreateContentsForEntity(), GetCurrentTransformation(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), and impeller::Paint::WithFilters().

Referenced by impeller::DlDispatcher::drawArc(), DrawCircle(), impeller::DlDispatcher::drawDRRect(), impeller::DlDispatcher::drawLine(), impeller::DlDispatcher::drawOval(), impeller::DlDispatcher::drawPath(), impeller::DlDispatcher::drawPoints(), DrawRect(), DrawRRect(), impeller::DlDispatcher::drawRRect(), impeller::DlDispatcher::drawShadow(), and impeller::testing::TEST_P().

DrawPicture()

void impeller::Canvas::DrawPicture

(

const Picture &

picture

)

Definition at line 437 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(GetStencilDepth());
      entity->SetTransformation(GetCurrentTransformation() *
                                entity->GetTransformation());
      return true;
    }
 
    if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) {
      subpass->get()->SetStencilDepth(subpass->get()->GetStencilDepth() +
                                      GetStencilDepth());
      return true;
    }
 
    FML_UNREACHABLE();
  });
 
  GetCurrentPass().AddSubpassInline(std::move(pass));
 
  RestoreClip();
}

References impeller::EntityPass::AddSubpassInline(), GetCurrentTransformation(), 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 418 of file canvas.cc.

                                                {
  if (radius <= 0) {
    return;
  }
 
  Entity entity;
  entity.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(paint.CreateContentsForGeometry(
      Geometry::MakePointField(std::move(points), radius,
                               /*round=*/point_style == PointStyle::kRound))));
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, impeller::Paint::CreateContentsForGeometry(), GetCurrentTransformation(), impeller::kRound, impeller::Geometry::MakePointField(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), and impeller::Paint::WithFilters().

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

DrawRect()

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

Definition at line 229 of file canvas.cc.

                                                   {
  if (paint.style == Paint::Style::kStroke) {
    DrawPath(PathBuilder{}.AddRect(rect).TakePath(), paint);
    return;
  }
 
  if (AttemptDrawBlurredRRect(rect, 0, paint)) {
    return;
  }
 
  Entity entity;
  entity.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(
      paint.CreateContentsForGeometry(Geometry::MakeRect(rect))));
 
  GetCurrentPass().AddEntity(entity);
}

References impeller::EntityPass::AddEntity(), impeller::PathBuilder::AddRect(), impeller::Paint::blend_mode, impeller::Paint::CreateContentsForGeometry(), DrawPath(), GetCurrentTransformation(), impeller::Paint::kStroke, impeller::Geometry::MakeRect(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), impeller::Paint::style, and impeller::Paint::WithFilters().

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

DrawRRect()

void impeller::Canvas::DrawRRect	(	Rect	rect,
		Scalar	corner_radius,
		const Paint &	paint
	)

Definition at line 249 of file canvas.cc.

                                                                          {
  if (AttemptDrawBlurredRRect(rect, corner_radius, paint)) {
    return;
  }
  auto path = PathBuilder{}
                  .SetConvexity(Convexity::kConvex)
                  .AddRoundedRect(rect, corner_radius)
                  .TakePath();
  if (paint.style == Paint::Style::kFill) {
    Entity entity;
    entity.SetTransformation(GetCurrentTransformation());
    entity.SetStencilDepth(GetStencilDepth());
    entity.SetBlendMode(paint.blend_mode);
    entity.SetContents(paint.WithFilters(
        paint.CreateContentsForGeometry(Geometry::MakeFillPath(path))));
 
    GetCurrentPass().AddEntity(entity);
    return;
  }
  DrawPath(path, paint);
}

References impeller::EntityPass::AddEntity(), impeller::PathBuilder::AddRoundedRect(), impeller::Paint::blend_mode, impeller::Paint::CreateContentsForGeometry(), DrawPath(), GetCurrentTransformation(), impeller::kConvex, impeller::Paint::kFill, impeller::Geometry::MakeFillPath(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::PathBuilder::SetConvexity(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), impeller::Paint::style, impeller::PathBuilder::TakePath(), and impeller::Paint::WithFilters().

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

                                               {
  Entity entity;
  entity.SetStencilDepth(GetStencilDepth());
  entity.SetBlendMode(paint.blend_mode);
 
  auto text_contents = std::make_shared<TextContents>();
  text_contents->SetTextFrame(text_frame);
  text_contents->SetColor(paint.color);
 
  entity.SetTransformation(GetCurrentTransformation() *
                           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(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransformation(), impeller::Matrix::MakeTranslation(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), 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 592 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.SetTransformation(GetCurrentTransformation());
  entity.SetStencilDepth(GetStencilDepth());
  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)) {
    auto contents = paint.CreateContentsForGeometry(vertices);
    entity.SetContents(paint.WithFilters(std::move(contents)));
    GetCurrentPass().AddEntity(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(entity);
}

References impeller::EntityPass::AddEntity(), impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_source, impeller::Paint::CreateContentsForGeometry(), GetCurrentTransformation(), impeller::ColorSource::GetType(), impeller::ColorSource::kColor, impeller::kDestination, impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetStencilDepth(), impeller::Entity::SetTransformation(), 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 513 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 132 of file canvas.cc.

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

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

GetCurrentTransformation()

const Matrix & impeller::Canvas::GetCurrentTransformation

(

)

const

Definition at line 128 of file canvas.cc.

                                                     {
  return xformation_stack_.back().xformation;
}

Referenced by Concat(), DrawAtlas(), impeller::DlDispatcher::drawDisplayList(), DrawImageRect(), 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 161 of file canvas.cc.

                                  {
  return xformation_stack_.size();
}

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

PreConcat()

void impeller::Canvas::PreConcat

(

const Matrix &

xformation

)

Definition at line 116 of file canvas.cc.

                                               {
  xformation_stack_.back().xformation = xformation * GetCurrentTransformation();
}

References GetCurrentTransformation().

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

ResetTransform()

void impeller::Canvas::ResetTransform

(

)

Definition at line 120 of file canvas.cc.

                            {
  xformation_stack_.back().xformation = {};
}

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

Restore()

bool impeller::Canvas::Restore

(

)

Definition at line 91 of file canvas.cc.

                     {
  FML_DCHECK(xformation_stack_.size() > 0);
  if (xformation_stack_.size() == 1) {
    return false;
  }
  if (xformation_stack_.back().rendering_mode ==
      Entity::RenderingMode::kSubpass) {
    current_pass_ = GetCurrentPass().GetSuperpass();
    FML_DCHECK(current_pass_);
  }
 
  bool contains_clips = xformation_stack_.back().contains_clips;
  xformation_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(), and impeller::testing::TEST_P().

RestoreToCount()

void impeller::Canvas::RestoreToCount

(

size_t

count

)

Definition at line 165 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 157 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 55 of file canvas.cc.

                  {
  Save(false);
}

Referenced by impeller::DlDispatcher::drawDisplayList(), impeller::DlDispatcher::drawShadow(), impeller::DlDispatcher::save(), SaveLayer(), 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 532 of file canvas.cc.

                                                                          {
  Save(true, paint.blend_mode, backdrop_filter);
 
  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::kSourceOver, and Save().

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

Scale() [1/2]

void impeller::Canvas::Scale

(

const Vector2 &

scale

)

Definition at line 145 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 149 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 153 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 &

xformation

)

Definition at line 124 of file canvas.cc.

                                               {
  Concat(xformation);
}

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 141 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