impeller::Canvas Class Reference

#include <canvas.h>

Inheritance diagram for impeller::Canvas:

Public Member Functions
	Canvas ()
	Canvas (Rect cull_rect)
	Canvas (IRect cull_rect)
virtual	~Canvas ()
virtual void	Save (uint32_t total_content_depth=kMaxDepth)
virtual void	SaveLayer (const Paint &paint, std::optional< Rect > bounds=std::nullopt, const std::shared_ptr< ImageFilter > &backdrop_filter=nullptr, ContentBoundsPromise bounds_promise=ContentBoundsPromise::kUnknown, uint32_t total_content_depth=kMaxDepth, bool can_distribute_opacity=false)
virtual 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 (const 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={}, SourceRectConstraint src_rect_constraint=SourceRectConstraint::kFast)
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	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)
virtual 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 ()

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

Protected Member Functions
size_t	GetClipHeight () const
void	Initialize (std::optional< Rect > cull_rect)
void	Reset ()

Protected Attributes
std::deque< CanvasStackEntry >	transform_stack_
std::optional< Rect >	initial_cull_rect_
uint64_t	current_depth_ = 0u

Private Member Functions
virtual void	AddRenderEntityToCurrentPass (Entity entity, bool reuse_depth=false)
virtual void	AddClipEntityToCurrentPass (Entity entity)
virtual void	Save (bool create_subpass, uint32_t total_content_depth, BlendMode=BlendMode::kSourceOver, const std::shared_ptr< ImageFilter > &backdrop_filter=nullptr)

Detailed Description

Definition at line 60 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/3]

impeller::Canvas::Canvas

(

)

Definition at line 149 of file canvas.cc.

               {
  Initialize(std::nullopt);
}

Canvas() [2/3]

impeller::Canvas::Canvas ( Rect  cull_rect )

explicit

Definition at line 153 of file canvas.cc.

                             {
  Initialize(cull_rect);
}

Canvas() [3/3]

impeller::Canvas::Canvas ( IRect  cull_rect )

explicit

Definition at line 157 of file canvas.cc.

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

~Canvas()

impeller::Canvas::~Canvas ( )

virtualdefault

Member Function Documentation

AddClipEntityToCurrentPass()

void impeller::Canvas::AddClipEntityToCurrentPass ( Entity  entity )

privatevirtual

Definition at line 838 of file canvas.cc.

                                                     {
  GetCurrentPass().PushClip(std::move(entity));
}

AddRenderEntityToCurrentPass()

void impeller::Canvas::AddRenderEntityToCurrentPass ( Entity  entity, bool  reuse_depth = false  )

privatevirtual

Definition at line 829 of file canvas.cc.

                                                                         {
  if (!reuse_depth) {
    ++current_depth_;
  }
  entity.SetClipDepth(current_depth_);
  entity.SetInheritedOpacity(transform_stack_.back().distributed_opacity);
  GetCurrentPass().AddEntity(std::move(entity));
}

ClipOval()

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

Definition at line 620 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;
  }
}

ClipPath()

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

Definition at line 589 of file canvas.cc.

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

ClipRect()

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

Definition at line 599 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;
  }
}

ClipRRect()

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

Definition at line 640 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;
  }
}

Concat()

void impeller::Canvas::Concat

(

const Matrix &

transform

)

Definition at line 282 of file canvas.cc.

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

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 1020 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.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(contents));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawCircle()

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

Definition at line 566 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.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)));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawImage()

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

Definition at line 752 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));
}

DrawImageRect()

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

Definition at line 766 of file canvas.cc.

                                                                     {
  if (!image || source.IsEmpty() || dest.IsEmpty()) {
    return;
  }
 
  auto size = image->GetSize();
 
  if (size.IsEmpty()) {
    return;
  }
 
  auto texture_contents = TextureContents::MakeRect(dest);
  texture_contents->SetTexture(image->GetTexture());
  texture_contents->SetSourceRect(source);
  texture_contents->SetStrictSourceRect(src_rect_constraint ==
                                        SourceRectConstraint::kStrict);
  texture_contents->SetSamplerDescriptor(std::move(sampler));
  texture_contents->SetOpacity(paint.color.alpha);
  texture_contents->SetDeferApplyingOpacity(paint.HasColorFilter());
 
  std::shared_ptr<Contents> contents = texture_contents;
  if (paint.mask_blur_descriptor.has_value()) {
    contents = paint.mask_blur_descriptor->CreateMaskBlur(texture_contents);
  }
 
  Entity entity;
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(paint.WithFilters(contents));
  entity.SetTransform(GetCurrentTransform());
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawLine()

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

Definition at line 485 of file canvas.cc.

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

DrawOval()

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

Definition at line 514 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.SetBlendMode(paint.blend_mode);
  entity.SetContents(
      CreateContentsForGeometryWithFilters(paint, Geometry::MakeOval(rect)));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawPaint()

void impeller::Canvas::DrawPaint

(

const Paint &

paint

)

Definition at line 352 of file canvas.cc.

                                         {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
  entity.SetContents(CreateCoverContentsWithFilters(paint));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawPath()

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

Definition at line 343 of file canvas.cc.

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

DrawPoints()

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

Definition at line 733 of file canvas.cc.

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

DrawRect()

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

Definition at line 495 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.SetBlendMode(paint.blend_mode);
  entity.SetContents(
      CreateContentsForGeometryWithFilters(paint, Geometry::MakeRect(rect)));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawRRect()

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

Definition at line 540 of file canvas.cc.

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

DrawTextFrame()

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

virtual

Reimplemented in impeller::ExperimentalCanvas.

Definition at line 884 of file canvas.cc.

                                               {
  Entity entity;
  entity.SetBlendMode(paint.blend_mode);
 
  auto text_contents = std::make_shared<TextContents>();
  text_contents->SetTextFrame(text_frame);
  text_contents->SetForceTextColor(paint.mask_blur_descriptor.has_value());
  text_contents->SetOffset(position);
  text_contents->SetColor(paint.color);
  text_contents->SetTextProperties(paint.color,                           //
                                   paint.style == Paint::Style::kStroke,  //
                                   paint.stroke_width,                    //
                                   paint.stroke_cap,                      //
                                   paint.stroke_join,                     //
                                   paint.stroke_miter                     //
  );
 
  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, GetCurrentTransform())));
 
  AddRenderEntityToCurrentPass(std::move(entity));
}

DrawVertices()

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

Definition at line 933 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.SetBlendMode(paint.blend_mode);
 
  // If there are no vertex colors.
  if (UseColorSourceContents(vertices, paint)) {
    entity.SetContents(CreateContentsForGeometryWithFilters(paint, vertices));
    AddRenderEntityToCurrentPass(std::move(entity));
    return;
  }
 
  // If the blend mode is destination don't bother to bind or create a texture.
  if (blend_mode == BlendMode::kDestination) {
    auto contents = std::make_shared<VerticesSimpleBlendContents>();
    contents->SetBlendMode(blend_mode);
    contents->SetAlpha(paint.color.alpha);
    contents->SetGeometry(vertices);
    entity.SetContents(paint.WithFilters(std::move(contents)));
    AddRenderEntityToCurrentPass(std::move(entity));
    return;
  }
 
  // If there is a texture, use this directly. Otherwise render the color
  // source to a texture.
  if (std::optional<ImageData> maybe_image_data =
          GetImageColorSourceData(paint.color_source)) {
    const ImageData& image_data = maybe_image_data.value();
    auto contents = std::make_shared<VerticesSimpleBlendContents>();
    contents->SetBlendMode(blend_mode);
    contents->SetAlpha(paint.color.alpha);
    contents->SetGeometry(vertices);
    contents->SetEffectTransform(image_data.effect_transform);
    contents->SetTexture(image_data.texture);
    contents->SetTileMode(image_data.x_tile_mode, image_data.y_tile_mode);
 
    entity.SetContents(paint.WithFilters(std::move(contents)));
    AddRenderEntityToCurrentPass(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 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<VerticesSimpleBlendContents>();
  contents->SetBlendMode(blend_mode);
  contents->SetAlpha(paint.color.alpha);
  contents->SetGeometry(vertices);
  contents->SetLazyTexture([src_contents](const ContentContext& renderer) {
    return src_contents->RenderToSnapshot(renderer, {})->texture;
  });
  entity.SetContents(paint.WithFilters(std::move(contents)));
  AddRenderEntityToCurrentPass(std::move(entity));
}

EndRecordingAsPicture()

Picture impeller::Canvas::EndRecordingAsPicture

(

)

Definition at line 804 of file canvas.cc.

                                      {
  // Assign clip depths to any outstanding clip entities.
  while (current_pass_ != nullptr) {
    current_pass_->PopAllClips(current_depth_);
    current_pass_ = current_pass_->GetSuperpass();
  }
 
  Picture picture;
  picture.pass = std::move(base_pass_);
 
  Reset();
  Initialize(initial_cull_rect_);
 
  return picture;
}

GetClipHeight()

size_t impeller::Canvas::GetClipHeight ( ) const

protected

Definition at line 825 of file canvas.cc.

                                   {
  return transform_stack_.back().clip_height;
}

GetCurrentLocalCullingBounds()

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

(

)

const

Definition at line 302 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;
}

GetCurrentTransform()

const Matrix & impeller::Canvas::GetCurrentTransform

(

)

const

Definition at line 298 of file canvas.cc.

                                                {
  return transform_stack_.back().transform;
}

GetSaveCount()

size_t impeller::Canvas::GetSaveCount

(

)

const

Definition at line 331 of file canvas.cc.

                                  {
  return transform_stack_.size();
}

Initialize()

void impeller::Canvas::Initialize ( std::optional< Rect >  cull_rect )

protected

Definition at line 164 of file canvas.cc.

                                                   {
  initial_cull_rect_ = cull_rect;
  base_pass_ = std::make_unique<EntityPass>();
  base_pass_->SetClipDepth(++current_depth_);
  current_pass_ = base_pass_.get();
  transform_stack_.emplace_back(CanvasStackEntry{
      .cull_rect = cull_rect,
      .clip_depth = kMaxDepth,
  });
  FML_DCHECK(GetSaveCount() == 1u);
  FML_DCHECK(base_pass_->GetSubpassesDepth() == 1u);
}

PreConcat()

void impeller::Canvas::PreConcat

(

const Matrix &

transform

)

Definition at line 286 of file canvas.cc.

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

Reset()

void impeller::Canvas::Reset ( )

protected

Definition at line 177 of file canvas.cc.

                   {
  base_pass_ = nullptr;
  current_pass_ = nullptr;
  current_depth_ = 0u;
  transform_stack_ = {};
}

ResetTransform()

void impeller::Canvas::ResetTransform

(

)

Definition at line 290 of file canvas.cc.

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

Restore()

bool impeller::Canvas::Restore ( )

virtual

Reimplemented in impeller::ExperimentalCanvas.

Definition at line 257 of file canvas.cc.

                     {
  FML_DCHECK(transform_stack_.size() > 0);
  if (transform_stack_.size() == 1) {
    return false;
  }
  size_t num_clips = transform_stack_.back().num_clips;
  current_pass_->PopClips(num_clips, current_depth_);
 
  if (transform_stack_.back().rendering_mode ==
          Entity::RenderingMode::kSubpassAppendSnapshotTransform ||
      transform_stack_.back().rendering_mode ==
          Entity::RenderingMode::kSubpassPrependSnapshotTransform) {
    current_pass_->SetClipDepth(++current_depth_);
    current_pass_ = GetCurrentPass().GetSuperpass();
    FML_DCHECK(current_pass_);
  }
 
  transform_stack_.pop_back();
  if (num_clips > 0) {
    RestoreClip();
  }
 
  return true;
}

RestoreToCount()

void impeller::Canvas::RestoreToCount

(

size_t

count

)

Definition at line 335 of file canvas.cc.

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

Rotate()

void impeller::Canvas::Rotate

(

Radians

radians

)

Definition at line 327 of file canvas.cc.

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

Save() [1/2]

void impeller::Canvas::Save ( bool  create_subpass, uint32_t  total_content_depth, BlendMode  blend_mode = BlendMode::kSourceOver, const std::shared_ptr< ImageFilter > &  backdrop_filter = nullptr  )

privatevirtual

Definition at line 219 of file canvas.cc.

                                                                     {
  auto entry = CanvasStackEntry{};
  entry.transform = transform_stack_.back().transform;
  entry.cull_rect = transform_stack_.back().cull_rect;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.distributed_opacity = transform_stack_.back().distributed_opacity;
  if (create_subpass) {
    entry.rendering_mode =
        Entity::RenderingMode::kSubpassAppendSnapshotTransform;
    auto subpass = std::make_unique<EntityPass>();
    if (backdrop_filter) {
      EntityPass::BackdropFilterProc backdrop_filter_proc =
          [backdrop_filter = backdrop_filter->Clone()](
              const FilterInput::Ref& input, const Matrix& effect_transform,
              Entity::RenderingMode rendering_mode) {
            auto filter = backdrop_filter->WrapInput(input);
            filter->SetEffectTransform(effect_transform);
            filter->SetRenderingMode(rendering_mode);
            return filter;
          };
      subpass->SetBackdropFilter(backdrop_filter_proc);
      MipCountVisitor mip_count_visitor;
      backdrop_filter->Visit(mip_count_visitor);
      current_pass_->SetRequiredMipCount(
          std::max(current_pass_->GetRequiredMipCount(),
                   mip_count_visitor.GetRequiredMipCount()));
    }
    subpass->SetBlendMode(blend_mode);
    current_pass_ = GetCurrentPass().AddSubpass(std::move(subpass));
    current_pass_->SetTransform(transform_stack_.back().transform);
    current_pass_->SetClipHeight(transform_stack_.back().clip_height);
  }
  transform_stack_.emplace_back(entry);
}

Save() [2/2]

void impeller::Canvas::Save ( uint32_t  total_content_depth = kMaxDepth )

virtual

Reimplemented in impeller::ExperimentalCanvas.

Definition at line 184 of file canvas.cc.

                                              {
  Save(false, total_content_depth);
}

SaveLayer()

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

virtual

Reimplemented in impeller::ExperimentalCanvas.

Definition at line 842 of file canvas.cc.

                                                    {
  if (can_distribute_opacity && !backdrop_filter &&
      Paint::CanApplyOpacityPeephole(paint)) {
    Save(false, total_content_depth, paint.blend_mode, backdrop_filter);
    transform_stack_.back().distributed_opacity *= paint.color.alpha;
    return;
  }
  TRACE_EVENT0("flutter", "Canvas::saveLayer");
 
  Save(true, total_content_depth, 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();
  if (bounds) {
    new_layer_pass.SetBoundsLimit(bounds, bounds_promise);
  }
 
  if (paint.image_filter) {
    MipCountVisitor mip_count_visitor;
    paint.image_filter->Visit(mip_count_visitor);
    new_layer_pass.SetRequiredMipCount(mip_count_visitor.GetRequiredMipCount());
  }
  // 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;
 
  new_layer_pass.SetDelegate(std::make_shared<PaintPassDelegate>(paint_copy));
}

Scale() [1/2]

void impeller::Canvas::Scale

(

const Vector2 &

scale

)

Definition at line 315 of file canvas.cc.

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

Scale() [2/2]

void impeller::Canvas::Scale

(

const Vector3 &

scale

)

Definition at line 319 of file canvas.cc.

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

Skew()

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

Definition at line 323 of file canvas.cc.

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

Transform()

void impeller::Canvas::Transform

(

const Matrix &

transform

)

Definition at line 294 of file canvas.cc.

                                              {
  Concat(transform);
}

Translate()

void impeller::Canvas::Translate

(

const Vector3 &

offset

)

Definition at line 311 of file canvas.cc.

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

Member Data Documentation

current_depth_

uint64_t impeller::Canvas::current_depth_ = 0u

protected

Definition at line 183 of file canvas.h.

initial_cull_rect_

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

protected

Definition at line 182 of file canvas.h.

kMaxDepth

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

staticconstexpr

Definition at line 62 of file canvas.h.

transform_stack_

std::deque<CanvasStackEntry> impeller::Canvas::transform_stack_

protected

Definition at line 181 of file canvas.h.

---

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

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