impeller::Canvas Class Reference

#include <canvas.h>

Classes
struct	SaveLayerState

Public Types
using	BackdropFilterProc = std::function< std::shared_ptr< FilterContents >(FilterInput::Ref, const Matrix &effect_transform, Entity::RenderingMode rendering_mode)>

Public Member Functions
	Canvas (ContentContext &renderer, RenderTarget &render_target, bool requires_readback)
	Canvas (ContentContext &renderer, RenderTarget &render_target, bool requires_readback, Rect cull_rect)
	Canvas (ContentContext &renderer, RenderTarget &render_target, bool requires_readback, IRect cull_rect)
	~Canvas ()=default
std::optional< Rect >	GetLocalCoverageLimit () const
	Return the culling bounds of the current render target, or nullopt if there is no coverage. More...
void	Save (uint32_t total_content_depth=kMaxDepth)
void	SaveLayer (const Paint &paint, std::optional< Rect > bounds=std::nullopt, const flutter::DlImageFilter *backdrop_filter=nullptr, ContentBoundsPromise bounds_promise=ContentBoundsPromise::kUnknown, uint32_t total_content_depth=kMaxDepth, bool can_distribute_opacity=false)
bool	Restore ()
size_t	GetSaveCount () const
void	RestoreToCount (size_t count)
const Matrix &	GetCurrentTransform () const
void	ResetTransform ()
void	Transform (const Matrix &transform)
void	Concat (const Matrix &transform)
void	PreConcat (const Matrix &transform)
void	Translate (const Vector3 &offset)
void	Scale (const Vector2 &scale)
void	Scale (const Vector3 &scale)
void	Skew (Scalar sx, Scalar sy)
void	Rotate (Radians radians)
void	DrawPath (const 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< Texture > &image, Point offset, const Paint &paint, SamplerDescriptor sampler={})
void	DrawImageRect (const std::shared_ptr< Texture > &image, Rect source, Rect dest, const Paint &paint, SamplerDescriptor sampler={}, SourceRectConstraint src_rect_constraint=SourceRectConstraint::kFast)
void	DrawTextFrame (const std::shared_ptr< TextFrame > &text_frame, Point position, const Paint &paint)
void	DrawVertices (const std::shared_ptr< VerticesGeometry > &vertices, BlendMode blend_mode, const Paint &paint)
void	DrawAtlas (const std::shared_ptr< AtlasContents > &atlas_contents, const Paint &paint)
void	ClipGeometry (std::unique_ptr< Geometry > geometry, Entity::ClipOperation clip_op)
void	EndReplay ()
uint64_t	GetOpDepth () const
uint64_t	GetMaxOpDepth () const

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

Detailed Description

Definition at line 101 of file canvas.h.

Member Typedef Documentation

BackdropFilterProc

using impeller::Canvas::BackdropFilterProc = std::function<std::shared_ptr<FilterContents>( FilterInput::Ref, const Matrix& effect_transform, Entity::RenderingMode rendering_mode)>

Definition at line 108 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/3]

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

Definition at line 263 of file canvas.cc.

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

Canvas() [2/3]

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

explicit

Definition at line 275 of file canvas.cc.

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

Canvas() [3/3]

impeller::Canvas::Canvas ( ContentContext &  renderer, RenderTarget &  render_target, bool  requires_readback, IRect  cull_rect  )

explicit

Definition at line 288 of file canvas.cc.

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

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

~Canvas()

impeller::Canvas::~Canvas ( )

default

Member Function Documentation

ClipGeometry()

void impeller::Canvas::ClipGeometry	(	std::unique_ptr< Geometry >	geometry,
		Entity::ClipOperation	clip_op
	)

Definition at line 651 of file canvas.cc.

                                                       {
  clip_geometry_.push_back(std::move(geometry));
 
  auto contents = std::make_shared<ClipContents>();
  contents->SetGeometry(clip_geometry_.back().get());
  contents->SetClipOperation(clip_op);
 
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetContents(std::move(contents));
 
  AddClipEntityToCurrentPass(entity);
 
  ++transform_stack_.back().clip_height;
  ++transform_stack_.back().num_clips;
}

References GetCurrentTransform(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

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

Concat()

void impeller::Canvas::Concat

(

const Matrix &

transform

)

Definition at line 315 of file canvas.cc.

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

References GetCurrentTransform(), and transform.

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

DrawAtlas()

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

Definition at line 868 of file canvas.cc.

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

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

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

DrawCircle()

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

Definition at line 628 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);
 
  if (paint.style == Paint::Style::kStroke) {
    CircleGeometry geom(center, radius, paint.stroke_width);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    CircleGeometry geom(center, radius);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Paint::kStroke, impeller::TRect< Scalar >::MakeOriginSize(), impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke_width, and impeller::Paint::style.

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

DrawImage()

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

Definition at line 698 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(), impeller::TRect< Scalar >::MakeSize(), and offset.

DrawImageRect()

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

Definition at line 712 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);
  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());
 
  Entity entity;
  entity.SetBlendMode(paint.blend_mode);
  entity.SetTransform(GetCurrentTransform());
 
  if (!paint.mask_blur_descriptor.has_value()) {
    entity.SetContents(paint.WithFilters(std::move(texture_contents)));
    AddRenderEntityToCurrentPass(entity);
    return;
  }
 
  RectGeometry out_rect(Rect{});
 
  entity.SetContents(paint.WithFilters(
      paint.mask_blur_descriptor->CreateMaskBlur(texture_contents, &out_rect)));
  AddRenderEntityToCurrentPass(entity);
}

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

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

DrawLine()

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

Definition at line 546 of file canvas.cc.

                                                                          {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  LineGeometry geom(p0, p1, paint.stroke_width, paint.stroke_cap);
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

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

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

DrawOval()

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

Definition at line 573 of file canvas.cc.

                                                          {
  // TODO(jonahwilliams): This additional condition avoids an assert in the
  // stroke circle geometry generator. I need to verify the condition that this
  // assert prevents.
  if (rect.IsSquare() && (paint.style == Paint::Style::kFill ||
                          (paint.style == Paint::Style::kStroke &&
                           paint.stroke_width < rect.GetWidth()))) {
    // Circles have slightly less overhead and can do stroking
    DrawCircle(rect.GetCenter(), rect.GetWidth() * 0.5f, paint);
    return;
  }
 
  if (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);
 
  EllipseGeometry geom(rect);
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

References 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::kFill, impeller::Paint::kStroke, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke_width, and impeller::Paint::style.

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

DrawPaint()

void impeller::Canvas::DrawPaint

(

const Paint &

paint

)

Definition at line 401 of file canvas.cc.

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

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

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

DrawPath()

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

Definition at line 386 of file canvas.cc.

                                                          {
  Entity entity;
  entity.SetTransform(GetCurrentTransform());
  entity.SetBlendMode(paint.blend_mode);
 
  if (paint.style == Paint::Style::kFill) {
    FillPathGeometry geom(path);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  } else {
    StrokePathGeometry geom(path, paint.stroke_width, paint.stroke_miter,
                            paint.stroke_cap, paint.stroke_join);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
  }
}

References impeller::Paint::blend_mode, GetCurrentTransform(), impeller::Paint::kFill, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), impeller::Paint::stroke_cap, impeller::Paint::stroke_join, impeller::Paint::stroke_miter, impeller::Paint::stroke_width, and impeller::Paint::style.

Referenced by impeller::DlDispatcherBase::drawArc(), impeller::DlDispatcherBase::drawDashedLine(), impeller::DlDispatcherBase::drawDRRect(), DrawOval(), DrawRect(), impeller::DlDispatcherBase::drawRRect(), DrawRRect(), and impeller::DlDispatcherBase::SimplifyOrDrawPath().

DrawPoints()

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

Definition at line 681 of file canvas.cc.

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

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

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

DrawRect()

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

Definition at line 555 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);
 
  RectGeometry geom(rect);
  AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
}

References impeller::PathBuilder::AddRect(), impeller::Paint::blend_mode, DrawPath(), GetCurrentTransform(), impeller::Paint::kStroke, impeller::Entity::SetBlendMode(), impeller::Entity::SetTransform(), and impeller::Paint::style.

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

DrawRRect()

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

Definition at line 603 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);
 
    RoundRectGeometry geom(rect, corner_radii);
    AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
    return;
  }
 
  auto path = PathBuilder{}
                  .SetConvexity(Convexity::kConvex)
                  .AddRoundedRect(rect, corner_radii)
                  .SetBounds(rect)
                  .TakePath();
  DrawPath(path, paint);
}

References impeller::PathBuilder::AddRoundedRect(), impeller::Paint::blend_mode, DrawPath(), GetCurrentTransform(), impeller::kConvex, impeller::Paint::kFill, impeller::Entity::SetBlendMode(), impeller::PathBuilder::SetBounds(), impeller::PathBuilder::SetConvexity(), impeller::Entity::SetTransform(), impeller::Paint::style, and impeller::PathBuilder::TakePath().

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

DrawTextFrame()

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

Definition at line 1309 of file canvas.cc.

                                               {
  Entity entity;
  entity.SetClipDepth(GetClipHeight());
  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->SetScale(GetCurrentTransform().GetMaxBasisLengthXY());
  text_contents->SetColor(paint.color);
  text_contents->SetOffset(position);
  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(entity, false);
}

References impeller::Paint::blend_mode, impeller::Paint::color, GetCurrentTransform(), impeller::Paint::kStroke, impeller::Matrix::MakeTranslation(), impeller::Paint::mask_blur_descriptor, impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Paint::stroke_cap, impeller::Paint::stroke_join, impeller::Paint::stroke_miter, impeller::Paint::stroke_width, impeller::Paint::style, impeller::Paint::WithFilters(), and impeller::Paint::WithMaskBlur().

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

DrawVertices()

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

Definition at line 758 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 ||
      paint.color_source->type() == flutter::DlColorSourceType::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)) {
    AddRenderEntityWithFiltersToCurrentPass(entity, vertices.get(), paint);
    return;
  }
 
  // If the blend mode is destination don't bother to bind or create a texture.
  if (blend_mode == BlendMode::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(entity);
    return;
  }
 
  // If there is a texture, use this directly. Otherwise render the color
  // source to a texture.
  if (paint.color_source &&
      paint.color_source->type() == flutter::DlColorSourceType::kImage) {
    const flutter::DlImageColorSource* image_color_source =
        paint.color_source->asImage();
    FML_DCHECK(image_color_source &&
               image_color_source->image()->impeller_texture());
    auto texture = image_color_source->image()->impeller_texture();
    auto x_tile_mode = static_cast<Entity::TileMode>(
        image_color_source->horizontal_tile_mode());
    auto y_tile_mode =
        static_cast<Entity::TileMode>(image_color_source->vertical_tile_mode());
    auto sampler_descriptor =
        skia_conversions::ToSamplerDescriptor(image_color_source->sampling());
    auto effect_transform =
        skia_conversions::ToMatrix(image_color_source->matrix());
 
    auto contents = std::make_shared<VerticesSimpleBlendContents>();
    contents->SetBlendMode(blend_mode);
    contents->SetAlpha(paint.color.alpha);
    contents->SetGeometry(vertices);
    contents->SetEffectTransform(effect_transform);
    contents->SetTexture(texture);
    contents->SetTileMode(x_tile_mode, y_tile_mode);
 
    entity.SetContents(paint.WithFilters(std::move(contents)));
    AddRenderEntityToCurrentPass(entity);
    return;
  }
 
  auto src_paint = paint;
  src_paint.color = paint.color.WithAlpha(1.0);
 
  std::shared_ptr<ColorSourceContents> src_contents =
      src_paint.CreateContents();
  src_contents->SetGeometry(vertices.get());
 
  // If the color source has an intrinsic size, then we use that to
  // create the src contents as a simplification. Otherwise we use
  // the extent of the texture coordinates to determine how large
  // the src contents should be. If neither has a value we fall back
  // to using the geometry coverage data.
  Rect src_coverage;
  auto size = src_contents->GetColorSourceSize();
  if (size.has_value()) {
    src_coverage = Rect::MakeXYWH(0, 0, size->width, size->height);
  } else {
    auto cvg = vertices->GetCoverage(Matrix{});
    FML_CHECK(cvg.has_value());
    src_coverage =
        // Covered by FML_CHECK.
        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
        vertices->GetTextureCoordinateCoverge().value_or(cvg.value());
  }
  src_contents = src_paint.CreateContents();
 
  clip_geometry_.push_back(Geometry::MakeRect(Rect::Round(src_coverage)));
  src_contents->SetGeometry(clip_geometry_.back().get());
 
  auto contents = std::make_shared<VerticesSimpleBlendContents>();
  contents->SetBlendMode(blend_mode);
  contents->SetAlpha(paint.color.alpha);
  contents->SetGeometry(vertices);
  contents->SetLazyTextureCoverage(src_coverage);
  contents->SetLazyTexture(
      [src_contents, src_coverage](const ContentContext& renderer) {
        // Applying the src coverage as the coverage limit prevents the 1px
        // coverage pad from adding a border that is picked up by developer
        // specified UVs.
        return src_contents
            ->RenderToSnapshot(renderer, {}, Rect::Round(src_coverage))
            ->texture;
      });
  entity.SetContents(paint.WithFilters(std::move(contents)));
  AddRenderEntityToCurrentPass(entity);
}

References impeller::Color::alpha, impeller::Paint::blend_mode, impeller::Paint::color, impeller::Paint::color_source, GetCurrentTransform(), impeller::kDestination, impeller::Geometry::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), impeller::TRect< Scalar >::Round(), impeller::Entity::SetBlendMode(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::skia_conversions::ToMatrix(), impeller::skia_conversions::ToSamplerDescriptor(), impeller::Color::WithAlpha(), and impeller::Paint::WithFilters().

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

EndReplay()

void impeller::Canvas::EndReplay

(

)

Definition at line 1639 of file canvas.cc.

                       {
  FML_DCHECK(render_passes_.size() == 1u);
  render_passes_.back().inline_pass_context->GetRenderPass(0);
  render_passes_.back().inline_pass_context->EndPass();
 
  // If requires_readback_ was true, then we rendered to an offscreen texture
  // instead of to the onscreen provided in the render target. Now we need to
  // draw or blit the offscreen back to the onscreen.
  if (requires_readback_) {
    BlitToOnscreen();
  }
 
  render_passes_.clear();
  renderer_.GetRenderTargetCache()->End();
  clip_geometry_.clear();
 
  Reset();
  Initialize(initial_cull_rect_);
}

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

GetCurrentTransform()

const Matrix & impeller::Canvas::GetCurrentTransform

(

)

const

Definition at line 331 of file canvas.cc.

                                                {
  return transform_stack_.back().transform;
}

Referenced by ClipGeometry(), Concat(), DrawAtlas(), DrawCircle(), impeller::DlDispatcherBase::drawDisplayList(), DrawImageRect(), DrawLine(), DrawOval(), DrawPaint(), DrawPath(), DrawPoints(), DrawRect(), DrawRRect(), impeller::DlDispatcherBase::drawShadow(), DrawTextFrame(), DrawVertices(), PreConcat(), and Restore().

GetLocalCoverageLimit()

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

(

)

const

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

Definition at line 951 of file canvas.cc.

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

References impeller::EntityPassClipStack::CurrentClipCoverage(), impeller::RenderTarget::GetRenderTargetSize(), impeller::EntityPassClipStack::HasCoverage(), impeller::TRect< T >::Intersection(), impeller::TRect< Scalar >::MakeOriginSize(), and impeller::TRect< Scalar >::MakeSize().

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

GetMaxOpDepth()

uint64_t impeller::Canvas::GetMaxOpDepth ( ) const

inline

Definition at line 218 of file canvas.h.

{ return transform_stack_.back().clip_depth; }

GetOpDepth()

uint64_t impeller::Canvas::GetOpDepth ( ) const

inline

Definition at line 216 of file canvas.h.

{ return current_depth_; }

GetSaveCount()

size_t impeller::Canvas::GetSaveCount

(

)

const

Definition at line 370 of file canvas.cc.

                                  {
  return transform_stack_.size();
}

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

PreConcat()

void impeller::Canvas::PreConcat

(

const Matrix &

transform

)

Definition at line 319 of file canvas.cc.

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

References GetCurrentTransform(), and transform.

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

ResetTransform()

void impeller::Canvas::ResetTransform

(

)

Definition at line 323 of file canvas.cc.

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

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

Restore()

bool impeller::Canvas::Restore

(

)

Definition at line 1134 of file canvas.cc.

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

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

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

RestoreToCount()

void impeller::Canvas::RestoreToCount

(

size_t

count

)

Definition at line 378 of file canvas.cc.

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

References GetSaveCount(), and Restore().

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

Rotate()

void impeller::Canvas::Rotate

(

Radians

radians

)

Definition at line 351 of file canvas.cc.

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

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

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

Save()

void impeller::Canvas::Save

(

uint32_t

total_content_depth = kMaxDepth

)

Definition at line 934 of file canvas.cc.

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

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

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

SaveLayer()

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

Definition at line 982 of file canvas.cc.

                                                    {
  TRACE_EVENT0("flutter", "Canvas::saveLayer");
  if (IsSkipping()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  auto maybe_coverage_limit = GetLocalCoverageLimit();
  if (!maybe_coverage_limit.has_value()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
  auto coverage_limit = maybe_coverage_limit.value();
 
  if (can_distribute_opacity && !backdrop_filter &&
      Paint::CanApplyOpacityPeephole(paint) &&
      bounds_promise != ContentBoundsPromise::kMayClipContents) {
    Save(total_content_depth);
    transform_stack_.back().distributed_opacity *= paint.color.alpha;
    return;
  }
 
  std::shared_ptr<FilterContents> filter_contents = paint.WithImageFilter(
      Rect(), transform_stack_.back().transform,
      Entity::RenderingMode::kSubpassPrependSnapshotTransform);
 
  std::optional<Rect> maybe_subpass_coverage = ComputeSaveLayerCoverage(
      bounds.value_or(Rect::MakeMaximum()),
      transform_stack_.back().transform,  //
      coverage_limit,                     //
      filter_contents,                    //
      /*flood_output_coverage=*/
      Entity::IsBlendModeDestructive(paint.blend_mode),  //
      /*flood_input_coverage=*/!!backdrop_filter         //
  );
 
  if (!maybe_subpass_coverage.has_value()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  auto subpass_coverage = maybe_subpass_coverage.value();
 
  // When an image filter is present, clamp to avoid flicking due to nearest
  // sampled image. For other cases, round out to ensure than any geometry is
  // not cut off.
  //
  // See also this bug: https://github.com/flutter/flutter/issues/144213
  //
  // TODO(jonahwilliams): this could still round out for filters that use decal
  // sampling mode.
  ISize subpass_size;
  bool did_round_out = false;
  if (paint.image_filter) {
    subpass_size = ISize(subpass_coverage.GetSize());
  } else {
    did_round_out = true;
    subpass_size = ISize(IRect::RoundOut(subpass_coverage).GetSize());
  }
  if (subpass_size.IsEmpty()) {
    return SkipUntilMatchingRestore(total_content_depth);
  }
 
  // When there are scaling filters present, these contents may exceed the
  // maximum texture size. Perform a clamp here, which may cause rendering
  // artifacts.
  subpass_size = subpass_size.Min(renderer_.GetContext()
                                      ->GetCapabilities()
                                      ->GetMaximumRenderPassAttachmentSize());
 
  // Backdrop filter state, ignored if there is no BDF.
  std::shared_ptr<FilterContents> backdrop_filter_contents;
  Point local_position = {0, 0};
  if (backdrop_filter) {
    local_position = subpass_coverage.GetOrigin() - GetGlobalPassPosition();
    Canvas::BackdropFilterProc backdrop_filter_proc =
        [backdrop_filter = backdrop_filter](
            const FilterInput::Ref& input, const Matrix& effect_transform,
            Entity::RenderingMode rendering_mode) {
          auto filter = WrapInput(backdrop_filter, input);
          filter->SetEffectTransform(effect_transform);
          filter->SetRenderingMode(rendering_mode);
          return filter;
        };
 
    auto input_texture = FlipBackdrop(render_passes_,           //
                                      GetGlobalPassPosition(),  //
                                      clip_coverage_stack_,     //
                                      renderer_                 //
    );
    if (!input_texture) {
      // Validation failures are logged in FlipBackdrop.
      return;
    }
 
    backdrop_filter_contents = backdrop_filter_proc(
        FilterInput::Make(std::move(input_texture)),
        transform_stack_.back().transform.Basis(),
        // When the subpass has a translation that means the math with
        // the snapshot has to be different.
        transform_stack_.back().transform.HasTranslation()
            ? Entity::RenderingMode::kSubpassPrependSnapshotTransform
            : Entity::RenderingMode::kSubpassAppendSnapshotTransform);
  }
 
  // When applying a save layer, absorb any pending distributed opacity.
  Paint paint_copy = paint;
  paint_copy.color.alpha *= transform_stack_.back().distributed_opacity;
  transform_stack_.back().distributed_opacity = 1.0;
 
  render_passes_.push_back(
      LazyRenderingConfig(renderer_,                                    //
                          CreateRenderTarget(renderer_,                 //
                                             subpass_size,              //
                                             Color::BlackTransparent()  //
                                             )));
  save_layer_state_.push_back(SaveLayerState{paint_copy, subpass_coverage});
 
  CanvasStackEntry entry;
  entry.transform = transform_stack_.back().transform;
  entry.clip_depth = current_depth_ + total_content_depth;
  FML_DCHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
      << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
      << " after allocating " << total_content_depth;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.rendering_mode = Entity::RenderingMode::kSubpassAppendSnapshotTransform;
  entry.did_round_out = did_round_out;
  transform_stack_.emplace_back(entry);
 
  // Start non-collapsed subpasses with a fresh clip coverage stack limited by
  // the subpass coverage. This is important because image filters applied to
  // save layers may transform the subpass texture after it's rendered,
  // causing parent clip coverage to get misaligned with the actual area that
  // the subpass will affect in the parent pass.
  clip_coverage_stack_.PushSubpass(subpass_coverage, GetClipHeight());
 
  if (backdrop_filter_contents) {
    // Render the backdrop entity.
    Entity backdrop_entity;
    backdrop_entity.SetContents(std::move(backdrop_filter_contents));
    backdrop_entity.SetTransform(
        Matrix::MakeTranslation(Vector3(-local_position)));
    backdrop_entity.SetClipDepth(std::numeric_limits<uint32_t>::max());
 
    backdrop_entity.Render(
        renderer_,
        *render_passes_.back().inline_pass_context->GetRenderPass(0).pass);
  }
}

References impeller::Color::alpha, impeller::Color::BlackTransparent(), impeller::Paint::blend_mode, impeller::Paint::CanApplyOpacityPeephole(), impeller::CanvasStackEntry::clip_depth, impeller::CanvasStackEntry::clip_height, impeller::Paint::color, impeller::ComputeSaveLayerCoverage(), impeller::CanvasStackEntry::did_round_out, impeller::ContentContext::GetContext(), GetLocalCoverageLimit(), impeller::Paint::image_filter, impeller::Entity::IsBlendModeDestructive(), impeller::kMayClipContents, impeller::Entity::kSubpassAppendSnapshotTransform, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeMaximum(), impeller::Matrix::MakeTranslation(), impeller::EntityPassClipStack::PushSubpass(), impeller::Entity::Render(), impeller::CanvasStackEntry::rendering_mode, impeller::TRect< T >::RoundOut(), Save(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), subpass_size, impeller::CanvasStackEntry::transform, impeller::Paint::WithImageFilter(), and impeller::WrapInput().

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

Scale() [1/2]

void impeller::Canvas::Scale

(

const Vector2 &

scale

)

Definition at line 339 of file canvas.cc.

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

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

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

Scale() [2/2]

void impeller::Canvas::Scale

(

const Vector3 &

scale

)

Definition at line 343 of file canvas.cc.

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

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

Skew()

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

Definition at line 347 of file canvas.cc.

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

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

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

Transform()

void impeller::Canvas::Transform

(

const Matrix &

transform

)

Definition at line 327 of file canvas.cc.

                                              {
  Concat(transform);
}

References Concat(), and transform.

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

Translate()

void impeller::Canvas::Translate

(

const Vector3 &

offset

)

Definition at line 335 of file canvas.cc.

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

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

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

Member Data Documentation

kMaxDepth

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

staticconstexpr

Definition at line 103 of file canvas.h.

---

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

• impeller/display_list/canvas.h
• impeller/display_list/canvas.cc