| Flutter Impeller |

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

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

## Detailed Description

Definition at line 118 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 122 of file canvas.h.

## Constructor & Destructor Documentation

## ◆ Canvas() [1/3]

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

Definition at line 198 of file canvas.cc.

202 : renderer_(renderer),
203 render_target_(render_target),
204 is_onscreen_(is_onscreen),
205 requires_readback_(requires_readback),
206 clip_coverage_stack_(EntityPassClipStack(
207 Rect::MakeSize(render_target.GetRenderTargetSize()))) {
208 Initialize(std::nullopt);
209 SetupRenderPass();
210 }
impeller::TRect< Scalar >::MakeSize
constexpr static TRect MakeSize(const TSize< U > &size)
Definition: rect.h:150

## ◆ Canvas() [2/3]

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

Definition at line 212 of file canvas.cc.

217 : renderer_(renderer),
218 render_target_(render_target),
219 is_onscreen_(is_onscreen),
220 requires_readback_(requires_readback),
221 clip_coverage_stack_(EntityPassClipStack(
222 Rect::MakeSize(render_target.GetRenderTargetSize()))) {
223 Initialize(cull_rect);
224 SetupRenderPass();
225 }

## ◆ Canvas() [3/3]

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

Definition at line 227 of file canvas.cc.

232 : renderer_(renderer),
233 render_target_(render_target),
234 is_onscreen_(is_onscreen),
235 requires_readback_(requires_readback),
236 clip_coverage_stack_(EntityPassClipStack(
237 Rect::MakeSize(render_target.GetRenderTargetSize()))) {
238 Initialize(Rect::MakeLTRB(cull_rect.GetLeft(), cull_rect.GetTop(),
239 cull_rect.GetRight(), cull_rect.GetBottom()));
240 SetupRenderPass();
241 }
impeller::TRect< Scalar >::MakeLTRB
constexpr static TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition: rect.h:129

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 | ( | const Geometry & | geometry,
|  | Entity::ClipOperation | clip_op,
|  | bool | is_aa = `true`
| ) |  |

Definition at line 827 of file canvas.cc.

829 {
830 if (IsSkipping()) {
831 return;
832 }
833
834 // Ideally the clip depth would be greater than the current rendering
835 // depth because any rendering calls that follow this clip operation will
836 // pre-increment the depth and then be rendering above our clip depth,
837 // but that case will be caught by the CHECK in AddRenderEntity above.
838 // In practice we sometimes have a clip set with no rendering after it
839 // and in such cases the current depth will equal the clip depth.
840 // Eventually the DisplayList should optimize these out, but it is hard
841 // to know if a clip will actually be used in advance of storing it in
842 // the DisplayList buffer.
843 // See https://github.com/flutter/flutter/issues/147021
844 FML_DCHECK(current_depth_ <= transform_stack_.back().clip_depth)
845 << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
846 uint32_t clip_depth = transform_stack_.back().clip_depth;
847
848 const Matrix clip_transform =
849 Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) *
850 GetCurrentTransform();
851
852 std::optional<Rect> clip_coverage = geometry.GetCoverage(clip_transform);
853 if (!clip_coverage.has_value()) {
854 return;
855 }
856
857 ClipContents clip_contents(
858 clip_coverage.value(),
859 /*is_axis_aligned_rect=*/geometry.IsAxisAlignedRect() &&
860 GetCurrentTransform().IsTranslationScaleOnly());
861 clip_contents.SetClipOperation(clip_op);
862
863 EntityPassClipStack::ClipStateResult clip_state_result =
864 clip_coverage_stack_.RecordClip(
865 clip_contents, //
866 /*transform=*/clip_transform, //
867 /*global_pass_position=*/GetGlobalPassPosition(), //
868 /*clip_depth=*/clip_depth, //
869 /*clip_height_floor=*/GetClipHeightFloor(), //
870 /*is_aa=*/is_aa);
871
872 if (clip_state_result.clip_did_change) {
873 // We only need to update the pass scissor if the clip state has changed.
874 SetClipScissor(
875 clip_coverage_stack_.CurrentClipCoverage(),
876 *render_passes_.back().GetInlinePassContext()->GetRenderPass(),
877 GetGlobalPassPosition());
878 }
879
880 ++transform_stack_.back().clip_height;
881 ++transform_stack_.back().num_clips;
882
883 if (!clip_state_result.should_render) {
884 return;
885 }
886
887 // Note: this is a bit of a hack. Its not possible to construct a geometry
888 // result without begninning the render pass. We should refactor the geometry
889 // objects so that they only need a reference to the render pass size and/or
890 // orthographic transform.
891 Entity entity;
892 entity.SetTransform(clip_transform);
893 entity.SetClipDepth(clip_depth);
894
895 GeometryResult geometry_result = geometry.GetPositionBuffer(
896 renderer_, //
897 entity, //
898 *render_passes_.back().GetInlinePassContext()->GetRenderPass() //
899 );
900 clip_contents.SetGeometry(geometry_result);
901 clip_coverage_stack_.GetLastReplayResult().clip_contents.SetGeometry(
902 geometry_result);
903
904 clip_contents.Render(
905 renderer_, *render_passes_.back().GetInlinePassContext()->GetRenderPass(),
906 clip_depth);
907 }
impeller::Canvas::GetCurrentTransform
const Matrix & GetCurrentTransform() const
Definition: canvas.cc:272
impeller::ClipContents::SetGeometry
void SetGeometry(GeometryResult geometry)
Set the pre-tessellated clip geometry.
Definition: clip_contents.cc:37
impeller::EntityPassClipStack::CurrentClipCoverage
std::optional< Rect > CurrentClipCoverage() const
Definition: entity_pass_clip_stack.cc:24
impeller::EntityPassClipStack::GetLastReplayResult
ReplayResult & GetLastReplayResult()
Definition: entity_pass_clip_stack.h:61
impeller::EntityPassClipStack::RecordClip
ClipStateResult RecordClip(const ClipContents &clip_contents, Matrix transform, Point global_pass_position, uint32_t clip_depth, size_t clip_height_floor, bool is_aa)
Definition: entity_pass_clip_stack.cc:100
impeller::EntityPassClipStack::ReplayResult::clip_contents
ClipContents clip_contents
Definition: entity_pass_clip_stack.h:26
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95

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

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

## ◆ Concat()

void impeller::Canvas::Concat | ( | const Matrix & | transform | ) |

Definition at line 256 of file canvas.cc.

256 {
257 transform_stack_.back().transform = GetCurrentTransform() * transform;
258 }
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:214

References GetCurrentTransform(), and transform.

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

## ◆ DrawArc()

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

Definition at line 679 of file canvas.cc.

679 {
680 Entity entity;
681 entity.SetTransform(GetCurrentTransform());
682 entity.SetBlendMode(paint.blend_mode);
683
684 if (paint.style == Paint::Style::kFill) {
685 ArcGeometry geom(arc);
686 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
687 return;
688 }
689
690 const Rect& oval_bounds = arc.GetOvalBounds();
691 if (paint.stroke.width > oval_bounds.GetSize().MaxDimension()) {
692 // This is a special case for rendering arcs whose stroke width is so large
693 // you are effectively drawing a sector of a circle.
694 // https://github.com/flutter/flutter/issues/158567
695 Arc expanded_arc(oval_bounds.Expand(Size(paint.stroke.width * 0.5f)),
696 arc.GetStart(), arc.GetSweep(), true);
697
698 ArcGeometry geom(expanded_arc);
699 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
700 return;
701 }
702
703 // IncludeCenter incurs lots of extra work for stroking an arc, including:
704 // - It introduces segments to/from the center point (not too hard).
705 // - It introduces joins on those segments (a bit more complicated).
706 // - Even if the sweep is >=360 degrees, we still draw the segment to
707 // the center and it basically looks like a pie cut into the complete
708 // boundary circle, as if the slice were cut, but not extracted
709 // (hard to express as a continuous kTriangleStrip).
710 if (!arc.IncludeCenter()) {
711 if (arc.IsFullCircle()) {
712 return DrawOval(oval_bounds, paint);
713 }
714
715 // Our fast stroking code only works for circular bounds as it assumes
716 // that the inner and outer radii can be scaled along each angular step
717 // of the arc - which is not true for elliptical arcs where the inner
718 // and outer samples are perpendicular to the traveling direction of the
719 // elliptical curve which may not line up with the center of the bounds.
720 //
721 // TODO(flar): It also only supports Butt and Square caps for now.
722 // See https://github.com/flutter/flutter/issues/169400
723 if (oval_bounds.IsSquare() && paint.stroke.cap != Cap::kRound) {
724 ArcGeometry geom(arc, paint.stroke);
725 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
726 return;
727 }
728 }
729
730 ArcStrokeGeometry geom(arc, paint.stroke);
731 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
732 }
impeller::Canvas::DrawOval
void DrawOval(const Rect &rect, const Paint &paint)
Definition: canvas.cc:650
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:792
impeller::Cap::kRound
@ kRound
impeller::Size
TSize< Scalar > Size
Definition: size.h:159
impeller::Paint::Style::kFill
@ kFill

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

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

## ◆ DrawAtlas()

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

Definition at line 1120 of file canvas.cc.

1121 {
1122 atlas_contents->SetAlpha(paint.color.alpha);
1123
1124 Entity entity;
1125 entity.SetTransform(GetCurrentTransform());
1126 entity.SetBlendMode(paint.blend_mode);
1127 entity.SetContents(paint.WithFilters(atlas_contents));
1128
1129 AddRenderEntityToCurrentPass(entity);
1130 }

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

806 {
807 Size half_size(radius, radius);
808 if (AttemptDrawBlurredRRect(
809 Rect::MakeOriginSize(center - half_size, half_size * 2),
810 {radius, radius}, paint)) {
811 return;
812 }
813
814 Entity entity;
815 entity.SetTransform(GetCurrentTransform());
816 entity.SetBlendMode(paint.blend_mode);
817
818 if (paint.style == Paint::Style::kStroke) {
819 CircleGeometry geom(center, radius, paint.stroke.width);
820 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
821 } else {
822 CircleGeometry geom(center, radius);
823 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
824 }
825 }
impeller::Paint::Style::kStroke
@ kStroke
impeller::TRect< Scalar >::MakeOriginSize
constexpr static TRect MakeOriginSize(const TPoint< Type > &origin, const TSize< Type > &size)
Definition: rect.h:144

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

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

## ◆ DrawDashedLine()

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

Definition at line 606 of file canvas.cc.

610 {
611 // Reasons to defer to regular DrawLine:
612 // - performance for degenerate and "regular line" cases
613 // - length is non-positive - DrawLine will draw appropriate "dot"
614 // - off_length is non-positive - no gaps, DrawLine will draw it solid
615 // - on_length is negative - invalid dashing
616 //
617 // Note that a 0 length "on" dash will draw "dot"s every "off" distance
618 // apart so we proceed with the dashing process in that case.
619 Scalar length = p0.GetDistance(p1);
620 if (length > 0.0f && on_length >= 0.0f && off_length > 0.0f) {
621 Entity entity;
622 entity.SetTransform(GetCurrentTransform());
623 entity.SetBlendMode(paint.blend_mode);
624
625 StrokeDashedLineGeometry geom(p0, p1, on_length, off_length, paint.stroke);
626 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
627 } else {
628 DrawLine(p0, p1, paint);
629 }
630 }
impeller::Canvas::DrawLine
void DrawLine(const Point &p0, const Point &p1, const Paint &paint, bool reuse_depth=false)
Definition: canvas.cc:584
impeller::Scalar
float Scalar
Definition: scalar.h:19

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

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

## ◆ DrawDiffRoundRect()

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

Definition at line 766 of file canvas.cc.

768 {
769 Entity entity;
770 entity.SetTransform(GetCurrentTransform());
771 entity.SetBlendMode(paint.blend_mode);
772
773 if (paint.style == Paint::Style::kFill) {
774 FillDiffRoundRectGeometry geom(outer, inner);
775 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
776 } else {
777 StrokeDiffRoundRectGeometry geom(outer, inner, paint.stroke);
778 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
779 }
780 }

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

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

## ◆ DrawImage()

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

Definition at line 927 of file canvas.cc.

930 {
931 if (!image) {
932 return;
933 }
934
935 const Rect source = Rect::MakeSize(image->GetSize());
936 const Rect dest = source.Shift(offset);
937
938 DrawImageRect(image, source, dest, paint, sampler);
939 }
impeller::Canvas::DrawImageRect
void DrawImageRect(const std::shared_ptr< Texture > &image, Rect source, Rect dest, const Paint &paint, const SamplerDescriptor &sampler={}, SourceRectConstraint src_rect_constraint=SourceRectConstraint::kFast)
Definition: canvas.cc:941
impeller::TRect::Shift
constexpr TRect< T > Shift(T dx, T dy) const
Returns a new rectangle translated by the given offset.
Definition: rect.h:606

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

## ◆ DrawImageRect()

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

Definition at line 941 of file canvas.cc.

946 {
947 if (!image || source.IsEmpty() || dest.IsEmpty()) {
948 return;
949 }
950
951 ISize size = image->GetSize();
952 if (size.IsEmpty()) {
953 return;
954 }
955
956 std::optional<Rect> clipped_source =
957 source.Intersection(Rect::MakeSize(size));
958 if (!clipped_source) {
959 return;
960 }
961
962 if (AttemptColorFilterOptimization(image, source, dest, paint, sampler,
963 src_rect_constraint)) {
964 return;
965 }
966
967 if (*clipped_source != source) {
968 Scalar sx = dest.GetWidth() / source.GetWidth();
969 Scalar sy = dest.GetHeight() / source.GetHeight();
970 Scalar tx = dest.GetLeft() - source.GetLeft() * sx;
971 Scalar ty = dest.GetTop() - source.GetTop() * sy;
972 Matrix src_to_dest = Matrix::MakeTranslateScale({sx, sy, 1}, {tx, ty, 0});
973 dest = clipped_source->TransformBounds(src_to_dest);
974 }
975
976 auto texture_contents = TextureContents::MakeRect(dest);
977 texture_contents->SetTexture(image);
978 texture_contents->SetSourceRect(*clipped_source);
979 texture_contents->SetStrictSourceRect(src_rect_constraint ==
980 SourceRectConstraint::kStrict);
981 texture_contents->SetSamplerDescriptor(sampler);
982 texture_contents->SetOpacity(paint.color.alpha);
983 texture_contents->SetDeferApplyingOpacity(paint.HasColorFilter());
984
985 Entity entity;
986 entity.SetBlendMode(paint.blend_mode);
987 entity.SetTransform(GetCurrentTransform());
988
989 if (!paint.mask_blur_descriptor.has_value()) {
990 entity.SetContents(paint.WithFilters(std::move(texture_contents)));
991 AddRenderEntityToCurrentPass(entity);
992 return;
993 }
994
995 FillRectGeometry out_rect(Rect{});
996
997 entity.SetContents(paint.WithFilters(
998 paint.mask_blur_descriptor->CreateMaskBlur(texture_contents, &out_rect)));
999 AddRenderEntityToCurrentPass(entity);
1000 }
impeller::TextureContents::MakeRect
static std::shared_ptr< TextureContents > MakeRect(Rect destination)
Definition: texture_contents.cc:28
impeller::SourceRectConstraint::kStrict
@ kStrict
Sample only within the source rectangle. May be slower.
impeller::ISize
ISize64 ISize
Definition: size.h:162
impeller::Matrix::MakeTranslateScale
static constexpr Matrix MakeTranslateScale(const Vector3 &s, const Vector3 &t)
Definition: matrix.h:113

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

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

## ◆ DrawLine()

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

Definition at line 584 of file canvas.cc.

587 {
588 Entity entity;
589 entity.SetTransform(GetCurrentTransform());
590 entity.SetBlendMode(paint.blend_mode);
591
592 auto geometry = std::make_unique<LineGeometry>(p0, p1, paint.stroke);
593
594 if (renderer_.GetContext()->GetFlags().antialiased_lines &&
595 !paint.color_filter && !paint.invert_colors && !paint.image_filter &&
596 !paint.mask_blur_descriptor.has_value() && !paint.color_source) {
597 auto contents = LineContents::Make(std::move(geometry), paint.color);
598 entity.SetContents(std::move(contents));
599 AddRenderEntityToCurrentPass(entity, reuse_depth);
600 } else {
601 AddRenderEntityWithFiltersToCurrentPass(entity, geometry.get(), paint,
602 /*reuse_depth=*/reuse_depth);
603 }
604 }
impeller::ContentContext::GetContext
std::shared_ptr< Context > GetContext() const
Definition: content_context.cc:950
impeller::LineContents::Make
static std::unique_ptr< LineContents > Make(std::unique_ptr< LineGeometry > geometry, Color color)
Definition: line_contents.cc:137

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

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

## ◆ DrawOval()

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

Definition at line 650 of file canvas.cc.

650 {
651 // TODO(jonahwilliams): This additional condition avoids an assert in the
652 // stroke circle geometry generator. I need to verify the condition that this
653 // assert prevents.
654 if (rect.IsSquare() && (paint.style == Paint::Style::kFill ||
655 (paint.style == Paint::Style::kStroke &&
656 paint.stroke.width < rect.GetWidth()))) {
657 // Circles have slightly less overhead and can do stroking
658 DrawCircle(rect.GetCenter(), rect.GetWidth() * 0.5f, paint);
659 return;
660 }
661
662 if (AttemptDrawBlurredRRect(rect, rect.GetSize() * 0.5f, paint)) {
663 return;
664 }
665
666 Entity entity;
667 entity.SetTransform(GetCurrentTransform());
668 entity.SetBlendMode(paint.blend_mode);
669
670 if (paint.style == Paint::Style::kStroke) {
671 StrokeEllipseGeometry geom(rect, paint.stroke);
672 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
673 } else {
674 EllipseGeometry geom(rect);
675 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
676 }
677 }
impeller::Canvas::DrawCircle
void DrawCircle(const Point &center, Scalar radius, const Paint &paint)
Definition: canvas.cc:804

References impeller::Paint::blend_mode, DrawCircle(), 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, impeller::Paint::style, and impeller::StrokeParameters::width.

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

## ◆ DrawPaint()

void impeller::Canvas::DrawPaint | ( | const Paint & | paint | ) |

Definition at line 341 of file canvas.cc.

341 {
342 Entity entity;
343 entity.SetTransform(GetCurrentTransform());
344 entity.SetBlendMode(paint.blend_mode);
345
346 CoverGeometry geom;
347 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
348 }

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

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

## ◆ DrawPath()

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

Definition at line 327 of file canvas.cc.

327 {
328 Entity entity;
329 entity.SetTransform(GetCurrentTransform());
330 entity.SetBlendMode(paint.blend_mode);
331
332 if (paint.style == Paint::Style::kFill) {
333 FillPathGeometry geom(path);
334 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
335 } else {
336 StrokePathGeometry geom(path, paint.stroke);
337 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
338 }
339 }

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

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

## ◆ DrawPoints()

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

Definition at line 909 of file canvas.cc.

913 {
914 if (radius <= 0) {
915 return;
916 }
917
918 Entity entity;
919 entity.SetTransform(GetCurrentTransform());
920 entity.SetBlendMode(paint.blend_mode);
921
922 PointFieldGeometry geom(points, count, radius,
923 /*round=*/point_style == PointStyle::kRound);
924 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
925 }
impeller::PointStyle::kRound
@ kRound
Points are drawn as squares.
points
std::vector< Point > points
Definition: tessellator_libtess.cc:76

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

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

## ◆ DrawRect()

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

Definition at line 632 of file canvas.cc.

632 {
633 if (AttemptDrawBlurredRRect(rect, {}, paint)) {
634 return;
635 }
636
637 Entity entity;
638 entity.SetTransform(GetCurrentTransform());
639 entity.SetBlendMode(paint.blend_mode);
640
641 if (paint.style == Paint::Style::kStroke) {
642 StrokeRectGeometry geom(rect, paint.stroke);
643 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
644 } else {
645 FillRectGeometry geom(rect);
646 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
647 }
648 }

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

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

## ◆ DrawRoundRect()

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

Definition at line 734 of file canvas.cc.

734 {
735 auto& rect = round_rect.GetBounds();
736 auto& radii = round_rect.GetRadii();
737 if (radii.AreAllCornersSame()) {
738 if (AttemptDrawBlurredRRect(rect, radii.top_left, paint)) {
739 return;
740 }
741
742 if (paint.style == Paint::Style::kFill) {
743 Entity entity;
744 entity.SetTransform(GetCurrentTransform());
745 entity.SetBlendMode(paint.blend_mode);
746
747 RoundRectGeometry geom(rect, radii.top_left);
748 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
749 return;
750 }
751 }
752
753 Entity entity;
754 entity.SetTransform(GetCurrentTransform());
755 entity.SetBlendMode(paint.blend_mode);
756
757 if (paint.style == Paint::Style::kFill) {
758 FillRoundRectGeometry geom(round_rect);
759 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
760 } else {
761 StrokeRoundRectGeometry geom(round_rect, paint.stroke);
762 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
763 }
764 }

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

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

## ◆ DrawRoundSuperellipse()

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

Definition at line 782 of file canvas.cc.

783 {
784 auto& rect = round_superellipse.GetBounds();
785 auto& radii = round_superellipse.GetRadii();
786 if (radii.AreAllCornersSame() &&
787 AttemptDrawBlurredRSuperellipse(rect, radii.top_left, paint)) {
788 return;
789 }
790
791 Entity entity;
792 entity.SetTransform(GetCurrentTransform());
793 entity.SetBlendMode(paint.blend_mode);
794
795 if (paint.style == Paint::Style::kFill) {
796 RoundSuperellipseGeometry geom(rect, radii);
797 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
798 } else {
799 StrokeRoundSuperellipseGeometry geom(round_superellipse, paint.stroke);
800 AddRenderEntityWithFiltersToCurrentPass(entity, &geom, paint);
801 }
802 }

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

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

## ◆ DrawTextFrame()

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

Definition at line 1669 of file canvas.cc.

1671 {
1672 Scalar max_scale = GetCurrentTransform().GetMaxBasisLengthXY();
1673 if (max_scale * text_frame->GetFont().GetMetrics().point_size >
1674 kMaxTextScale) {
1675 fml::StatusOr<flutter::DlPath> path = text_frame->GetPath();
1676 if (path.ok()) {
1677 Save(1);
1678 Concat(Matrix::MakeTranslation(position));
1679 DrawPath(path.value(), paint);
1680 Restore();
1681 return;
1682 }
1683 }
1684
1685 Entity entity;
1686 entity.SetClipDepth(GetClipHeight());
1687 entity.SetBlendMode(paint.blend_mode);
1688
1689 auto text_contents = std::make_shared<TextContents>();
1690 text_contents->SetTextFrame(text_frame);
1691 text_contents->SetForceTextColor(paint.mask_blur_descriptor.has_value());
1692 text_contents->SetScale(max_scale);
1693 text_contents->SetColor(paint.color);
1694 text_contents->SetOffset(position);
1695 text_contents->SetTextProperties(paint.color,
1696 paint.style == Paint::Style::kStroke
1697 ? std::optional(paint.stroke)
1698 : std::nullopt);
1699
1700 entity.SetTransform(GetCurrentTransform() *
1701 Matrix::MakeTranslation(position));
1702
1703 if (AttemptBlurredTextOptimization(text_frame, text_contents, entity,
1704 paint)) {
1705 return;
1706 }
1707
1708 entity.SetContents(paint.WithFilters(std::move(text_contents)));
1709 AddRenderEntityToCurrentPass(entity, false);
1710 }
impeller::Canvas::Restore
bool Restore()
Definition: canvas.cc:1478
impeller::Canvas::Concat
void Concat(const Matrix &transform)
Definition: canvas.cc:256
impeller::Canvas::DrawPath
void DrawPath(const flutter::DlPath &path, const Paint &paint)
Definition: canvas.cc:327
impeller::Canvas::Save
void Save(uint32_t total_content_depth=kMaxDepth)
Definition: canvas.cc:1186
impeller::kMaxTextScale
static constexpr Scalar kMaxTextScale
Definition: canvas.cc:1667
impeller::Matrix::GetMaxBasisLengthXY
Scalar GetMaxBasisLengthXY() const
Return the maximum scale applied specifically to either the X axis or Y axis unit vectors (the bases)...
Definition: matrix.h:328

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

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

## ◆ DrawVertices()

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

Definition at line 1006 of file canvas.cc.

1008 {
1009 // Override the blend mode with kDestination in order to match the behavior
1010 // of Skia's SK_LEGACY_IGNORE_DRAW_VERTICES_BLEND_WITH_NO_SHADER flag, which
1011 // is enabled when the Flutter engine builds Skia.
1012 if (!paint.color_source) {
1013 blend_mode = BlendMode::kDst;
1014 }
1015
1016 Entity entity;
1017 entity.SetTransform(GetCurrentTransform());
1018 entity.SetBlendMode(paint.blend_mode);
1019
1020 // If there are no vertex colors.
1021 if (UseColorSourceContents(vertices, paint)) {
1022 AddRenderEntityWithFiltersToCurrentPass(entity, vertices.get(), paint);
1023 return;
1024 }
1025
1026 // If the blend mode is destination don't bother to bind or create a texture.
1027 if (blend_mode == BlendMode::kDst) {
1028 auto contents = std::make_shared<VerticesSimpleBlendContents>();
1029 contents->SetBlendMode(blend_mode);
1030 contents->SetAlpha(paint.color.alpha);
1031 contents->SetGeometry(vertices);
1032 entity.SetContents(paint.WithFilters(std::move(contents)));
1033 AddRenderEntityToCurrentPass(entity);
1034 return;
1035 }
1036
1037 // If there is a texture, use this directly. Otherwise render the color
1038 // source to a texture.
1039 if (paint.color_source &&
1040 paint.color_source->type() == flutter::DlColorSourceType::kImage) {
1041 const flutter::DlImageColorSource* image_color_source =
1042 paint.color_source->asImage();
1043 FML_DCHECK(image_color_source &&
1044 image_color_source->image()->impeller_texture());
1045 auto texture = image_color_source->image()->impeller_texture();
1046 auto x_tile_mode = static_cast<Entity::TileMode>(
1047 image_color_source->horizontal_tile_mode());
1048 auto y_tile_mode =
1049 static_cast<Entity::TileMode>(image_color_source->vertical_tile_mode());
1050 auto sampler_descriptor =
1051 skia_conversions::ToSamplerDescriptor(image_color_source->sampling());
1052 auto effect_transform = image_color_source->matrix();
1053
1054 auto contents = std::make_shared<VerticesSimpleBlendContents>();
1055 contents->SetBlendMode(blend_mode);
1056 contents->SetAlpha(paint.color.alpha);
1057 contents->SetGeometry(vertices);
1058 contents->SetEffectTransform(effect_transform);
1059 contents->SetTexture(texture);
1060 contents->SetTileMode(x_tile_mode, y_tile_mode);
1061 contents->SetSamplerDescriptor(sampler_descriptor);
1062
1063 entity.SetContents(paint.WithFilters(std::move(contents)));
1064 AddRenderEntityToCurrentPass(entity);
1065 return;
1066 }
1067
1068 auto src_paint = paint;
1069 src_paint.color = paint.color.WithAlpha(1.0);
1070
1071 std::shared_ptr<ColorSourceContents> src_contents =
1072 src_paint.CreateContents();
1073 src_contents->SetGeometry(vertices.get());
1074
1075 // If the color source has an intrinsic size, then we use that to
1076 // create the src contents as a simplification. Otherwise we use
1077 // the extent of the texture coordinates to determine how large
1078 // the src contents should be. If neither has a value we fall back
1079 // to using the geometry coverage data.
1080 Rect src_coverage;
1081 auto size = src_contents->GetColorSourceSize();
1082 if (size.has_value()) {
1083 src_coverage = Rect::MakeXYWH(0, 0, size->width, size->height);
1084 } else {
1085 auto cvg = vertices->GetCoverage(Matrix{});
1086 FML_CHECK(cvg.has_value());
1087 auto texture_coverage = vertices->GetTextureCoordinateCoverage();
1088 if (texture_coverage.has_value()) {
1089 src_coverage =
1090 Rect::MakeOriginSize(texture_coverage->GetOrigin(),
1091 texture_coverage->GetSize().Max({1, 1}));
1092 } else {
1093 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
1094 src_coverage = cvg.value();
1095 }
1096 }
1097 src_contents = src_paint.CreateContents();
1098
1099 clip_geometry_.push_back(Geometry::MakeRect(Rect::Round(src_coverage)));
1100 src_contents->SetGeometry(clip_geometry_.back().get());
1101
1102 auto contents = std::make_shared<VerticesSimpleBlendContents>();
1103 contents->SetBlendMode(blend_mode);
1104 contents->SetAlpha(paint.color.alpha);
1105 contents->SetGeometry(vertices);
1106 contents->SetLazyTextureCoverage(src_coverage);
1107 contents->SetLazyTexture([src_contents,
1108 src_coverage](const ContentContext& renderer) {
1109 // Applying the src coverage as the coverage limit prevents the 1px
1110 // coverage pad from adding a border that is picked up by developer
1111 // specified UVs.
1112 auto snapshot =
1113 src_contents->RenderToSnapshot(renderer, {}, Rect::Round(src_coverage));
1114 return snapshot.has_value() ? snapshot->texture : nullptr;
1115 });
1116 entity.SetContents(paint.WithFilters(std::move(contents)));
1117 AddRenderEntityToCurrentPass(entity);
1118 }
impeller::Entity::TileMode
TileMode
Definition: entity.h:48
impeller::Geometry::MakeRect
static std::unique_ptr< Geometry > MakeRect(const Rect &rect)
Definition: geometry.cc:83
impeller::skia_conversions::ToSamplerDescriptor
impeller::SamplerDescriptor ToSamplerDescriptor(const flutter::DlImageSampling options)
Definition: skia_conversions.cc:24
impeller::BlendMode::kDst
@ kDst
impeller::TRect< Scalar >::Round
Round(const TRect< U > &r)
Definition: rect.h:699
impeller::TRect< Scalar >::MakeXYWH
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition: rect.h:136

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

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

## ◆ EndReplay()

void impeller::Canvas::EndReplay | ( |  | ) |

Definition at line 2091 of file canvas.cc.

2091 {
2092 FML_DCHECK(render_passes_.size() == 1u);
2093 render_passes_.back().GetInlinePassContext()->GetRenderPass();
2094 render_passes_.back().GetInlinePassContext()->EndPass(
2095 /*is_onscreen=*/!requires_readback_ && is_onscreen_);
2096 backdrop_data_.clear();
2097
2098 // If requires_readback_ was true, then we rendered to an offscreen texture
2099 // instead of to the onscreen provided in the render target. Now we need to
2100 // draw or blit the offscreen back to the onscreen.
2101 if (requires_readback_) {
2102 BlitToOnscreen(/*is_onscreen_=*/is_onscreen_);
2103 }
2104 if (!EnsureFinalMipmapGeneration()) {
2105 VALIDATION_LOG << "Failed to generate onscreen mipmaps.";
2106 }
2107 if (!renderer_.GetContext()->FlushCommandBuffers()) {
2108 // Not much we can do.
2109 VALIDATION_LOG << "Failed to submit command buffers";
2110 }
2111 render_passes_.clear();
2112 renderer_.GetRenderTargetCache()->End();
2113 clip_geometry_.clear();
2114
2115 Reset();
2116 Initialize(initial_cull_rect_);
2117 }
impeller::Canvas::EnsureFinalMipmapGeneration
bool EnsureFinalMipmapGeneration() const
Definition: canvas.cc:2073
impeller::ContentContext::GetRenderTargetCache
const std::shared_ptr< RenderTargetAllocator > & GetRenderTargetCache() const
Definition: content_context.h:269
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:91

References VALIDATION_LOG.

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

## ◆ EnsureFinalMipmapGeneration()

bool impeller::Canvas::EnsureFinalMipmapGeneration | ( |  | ) | const

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

Definition at line 2073 of file canvas.cc.

2073 {
2074 if (!render_target_.GetRenderTargetTexture()->NeedsMipmapGeneration()) {
2075 return true;
2076 }
2077 std::shared_ptr<CommandBuffer> cmd_buffer =
2078 renderer_.GetContext()->CreateCommandBuffer();
2079 if (!cmd_buffer) {
2080 return false;
2081 }
2082 std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
2083 if (!blit_pass) {
2084 return false;
2085 }
2086 blit_pass->GenerateMipmap(render_target_.GetRenderTargetTexture());
2087 blit_pass->EncodeCommands();
2088 return renderer_.GetContext()->EnqueueCommandBuffer(std::move(cmd_buffer));
2089 }
impeller::RenderTarget::GetRenderTargetTexture
std::shared_ptr< Texture > GetRenderTargetTexture() const
Definition: render_target.cc:176

## ◆ GetCurrentTransform()

const Matrix & impeller::Canvas::GetCurrentTransform | ( |  | ) | const

Definition at line 272 of file canvas.cc.

272 {
273 return transform_stack_.back().transform;
274 }

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

## ◆ GetLocalCoverageLimit()

std::optional< Rect > impeller::Canvas::GetLocalCoverageLimit | ( |  | ) | const

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

Definition at line 1203 of file canvas.cc.

1203 {
1204 if (!clip_coverage_stack_.HasCoverage()) {
1205 // The current clip is empty. This means the pass texture won't be
1206 // visible, so skip it.
1207 return std::nullopt;
1208 }
1209
1210 std::optional<Rect> maybe_current_clip_coverage =
1211 clip_coverage_stack_.CurrentClipCoverage();
1212 if (!maybe_current_clip_coverage.has_value()) {
1213 return std::nullopt;
1214 }
1215
1216 Rect current_clip_coverage = maybe_current_clip_coverage.value();
1217
1218 FML_CHECK(!render_passes_.empty());
1219 const LazyRenderingConfig& back_render_pass = render_passes_.back();
1220 std::shared_ptr<Texture> back_texture =
1221 back_render_pass.GetInlinePassContext()->GetTexture();
1222 FML_CHECK(back_texture) << "Context is valid:"
1223 << back_render_pass.GetInlinePassContext()->IsValid();
1224
1225 // The maximum coverage of the subpass. Subpasses textures should never
1226 // extend outside the parent pass texture or the current clip coverage.
1227 std::optional<Rect> maybe_coverage_limit =
1228 Rect::MakeOriginSize(GetGlobalPassPosition(),
1229 Size(back_texture->GetSize()))
1230 .Intersection(current_clip_coverage);
1231
1232 if (!maybe_coverage_limit.has_value() || maybe_coverage_limit->IsEmpty()) {
1233 return std::nullopt;
1234 }
1235
1236 return maybe_coverage_limit->Intersection(
1237 Rect::MakeSize(render_target_.GetRenderTargetSize()));
1238 }
impeller::EntityPassClipStack::HasCoverage
bool HasCoverage() const
Definition: entity_pass_clip_stack.cc:28
impeller::RenderTarget::GetRenderTargetSize
ISize GetRenderTargetSize() const
Definition: render_target.cc:171
impeller::TRect::Intersection
constexpr std::optional< TRect > Intersection(const TRect &o) const
Definition: rect.h:532

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

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

## ◆ GetMaxOpDepth()

uint64_t impeller::Canvas::GetMaxOpDepth | ( |  | ) | const
| inline

Definition at line 261 of file canvas.h.

261 { return transform_stack_.back().clip_depth; }

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

## ◆ GetOpDepth()

uint64_t impeller::Canvas::GetOpDepth | ( |  | ) | const
| inline

Definition at line 259 of file canvas.h.

259 { return current_depth_; }

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

## ◆ GetSaveCount()

size_t impeller::Canvas::GetSaveCount | ( |  | ) | const

Definition at line 311 of file canvas.cc.

311 {
312 return transform_stack_.size();
313 }

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

## ◆ PreConcat()

void impeller::Canvas::PreConcat | ( | const Matrix & | transform | ) |

Definition at line 260 of file canvas.cc.

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

References GetCurrentTransform(), and transform.

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

## ◆ RequiresReadback()

bool impeller::Canvas::RequiresReadback | ( |  | ) | const
| inline

Definition at line 269 of file canvas.h.

269 { return requires_readback_; }

## ◆ ResetTransform()

void impeller::Canvas::ResetTransform | ( |  | ) |

Definition at line 264 of file canvas.cc.

264 {
265 transform_stack_.back().transform = {};
266 }

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

## ◆ Restore()

bool impeller::Canvas::Restore | ( |  | ) |

Definition at line 1478 of file canvas.cc.

1478 {
1479 FML_DCHECK(transform_stack_.size() > 0);
1480 if (transform_stack_.size() == 1) {
1481 return false;
1482 }
1483
1484 // This check is important to make sure we didn't exceed the depth
1485 // that the clips were rendered at while rendering any of the
1486 // rendering ops. It is OK for the current depth to equal the
1487 // outgoing clip depth because that means the clipping would have
1488 // been successful up through the last rendering op, but it cannot
1489 // be greater.
1490 // Also, we bump the current rendering depth to the outgoing clip
1491 // depth so that future rendering operations are not clipped by
1492 // any of the pixels set by the expiring clips. It is OK for the
1493 // estimates used to determine the clip depth in save/saveLayer
1494 // to be overly conservative, but we need to jump the depth to
1495 // the clip depth so that the next rendering op will get a
1496 // larger depth (it will pre-increment the current_depth_ value).
1497 FML_DCHECK(current_depth_ <= transform_stack_.back().clip_depth)
1498 << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
1499 current_depth_ = transform_stack_.back().clip_depth;
1500
1501 if (IsSkipping()) {
1502 transform_stack_.pop_back();
1503 return true;
1504 }
1505
1506 if (transform_stack_.back().rendering_mode ==
1507 Entity::RenderingMode::kSubpassAppendSnapshotTransform ||
1508 transform_stack_.back().rendering_mode ==
1509 Entity::RenderingMode::kSubpassPrependSnapshotTransform) {
1510 auto lazy_render_pass = std::move(render_passes_.back());
1511 render_passes_.pop_back();
1512 // Force the render pass to be constructed if it never was.
1513 lazy_render_pass.GetInlinePassContext()->GetRenderPass();
1514
1515 SaveLayerState save_layer_state = save_layer_state_.back();
1516 save_layer_state_.pop_back();
1517 auto global_pass_position = GetGlobalPassPosition();
1518
1519 std::shared_ptr<Contents> contents = CreateContentsForSubpassTarget(
1520 save_layer_state.paint, //
1521 lazy_render_pass.GetInlinePassContext()->GetTexture(), //
1522 Matrix::MakeTranslation(Vector3{-global_pass_position}) * //
1523 transform_stack_.back().transform //
1524 );
1525
1526 lazy_render_pass.GetInlinePassContext()->EndPass();
1527
1528 // Round the subpass texture position for pixel alignment with the parent
1529 // pass render target. By default, we draw subpass textures with nearest
1530 // sampling, so aligning here is important for avoiding visual nearest
1531 // sampling errors caused by limited floating point precision when
1532 // straddling a half pixel boundary.
1533 Point subpass_texture_position;
1534 if (transform_stack_.back().did_round_out) {
1535 // Subpass coverage was rounded out, origin potentially moved "down" by
1536 // as much as a pixel.
1537 subpass_texture_position =
1538 (save_layer_state.coverage.GetOrigin() - global_pass_position)
1539 .Floor();
1540 } else {
1541 // Subpass coverage was truncated. Pick the closest phyiscal pixel.
1542 subpass_texture_position =
1543 (save_layer_state.coverage.GetOrigin() - global_pass_position)
1544 .Round();
1545 }
1546
1547 Entity element_entity;
1548 element_entity.SetClipDepth(++current_depth_);
1549 element_entity.SetContents(std::move(contents));
1550 element_entity.SetBlendMode(save_layer_state.paint.blend_mode);
1551 element_entity.SetTransform(
1552 Matrix::MakeTranslation(Vector3(subpass_texture_position)));
1553
1554 if (element_entity.GetBlendMode() > Entity::kLastPipelineBlendMode) {
1555 if (renderer_.GetDeviceCapabilities().SupportsFramebufferFetch()) {
1556 ApplyFramebufferBlend(element_entity);
1557 } else {
1558 // End the active pass and flush the buffer before rendering "advanced"
1559 // blends. Advanced blends work by binding the current render target
1560 // texture as an input ("destination"), blending with a second texture
1561 // input ("source"), writing the result to an intermediate texture, and
1562 // finally copying the data from the intermediate texture back to the
1563 // render target texture. And so all of the commands that have written
1564 // to the render target texture so far need to execute before it's bound
1565 // for blending (otherwise the blend pass will end up executing before
1566 // all the previous commands in the active pass).
1567 auto input_texture = FlipBackdrop(GetGlobalPassPosition());
1568 if (!input_texture) {
1569 return false;
1570 }
1571
1572 FilterInput::Vector inputs = {
1573 FilterInput::Make(input_texture,
1574 element_entity.GetTransform().Invert()),
1575 FilterInput::Make(element_entity.GetContents())};
1576 auto contents = ColorFilterContents::MakeBlend(
1577 element_entity.GetBlendMode(), inputs);
1578 contents->SetCoverageHint(element_entity.GetCoverage());
1579 element_entity.SetContents(std::move(contents));
1580 element_entity.SetBlendMode(BlendMode::kSrc);
1581 }
1582 }
1583
1584 element_entity.Render(
1585 renderer_, //
1586 *render_passes_.back().GetInlinePassContext()->GetRenderPass() //
1587 );
1588 clip_coverage_stack_.PopSubpass();
1589 transform_stack_.pop_back();
1590
1591 // We don't need to restore clips if a saveLayer was performed, as the clip
1592 // state is per render target, and no more rendering operations will be
1593 // performed as the render target workloaded is completed in the restore.
1594 return true;
1595 }
1596
1597 size_t num_clips = transform_stack_.back().num_clips;
1598 transform_stack_.pop_back();
1599
1600 if (num_clips > 0) {
1601 EntityPassClipStack::ClipStateResult clip_state_result =
1602 clip_coverage_stack_.RecordRestore(GetGlobalPassPosition(),
1603 GetClipHeight());
1604
1605 // Clip restores are never required with depth based clipping.
1606 FML_DCHECK(!clip_state_result.should_render);
1607 if (clip_state_result.clip_did_change) {
1608 // We only need to update the pass scissor if the clip state has changed.
1609 SetClipScissor(
1610 clip_coverage_stack_.CurrentClipCoverage(), //
1611 *render_passes_.back().GetInlinePassContext()->GetRenderPass(), //
1612 GetGlobalPassPosition() //
1613 );
1614 }
1615 }
1616
1617 return true;
1618 }
impeller::Capabilities::SupportsFramebufferFetch
virtual bool SupportsFramebufferFetch() const =0
Whether the context backend is able to support pipelines with shaders that read from the framebuffer ...
impeller::ColorFilterContents::MakeBlend
static std::shared_ptr< ColorFilterContents > MakeBlend(BlendMode blend_mode, FilterInput::Vector inputs, std::optional< Color > foreground_color=std::nullopt)
the [inputs] are expected to be in the order of dst, src.
Definition: color_filter_contents.cc:17
impeller::ContentContext::GetDeviceCapabilities
const Capabilities & GetDeviceCapabilities() const
Definition: content_context.cc:954
impeller::Entity::RenderingMode::kSubpassPrependSnapshotTransform
@ kSubpassPrependSnapshotTransform
impeller::Entity::RenderingMode::kSubpassAppendSnapshotTransform
@ kSubpassAppendSnapshotTransform
impeller::Entity::kLastPipelineBlendMode
static constexpr BlendMode kLastPipelineBlendMode
Definition: entity.h:28
impeller::EntityPassClipStack::RecordRestore
ClipStateResult RecordRestore(Point global_pass_position, size_t restore_height)
Definition: entity_pass_clip_stack.cc:54
impeller::EntityPassClipStack::PopSubpass
void PopSubpass()
Definition: entity_pass_clip_stack.cc:44
impeller::FilterInput::Make
static FilterInput::Ref Make(Variant input, bool msaa_enabled=true)
Definition: filter_input.cc:19
impeller::FilterInput::Vector
std::vector< FilterInput::Ref > Vector
Definition: filter_input.h:33
impeller::Point
TPoint< Scalar > Point
Definition: point.h:327
impeller::BlendMode::kSrc
@ kSrc

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

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

## ◆ RestoreToCount()

void impeller::Canvas::RestoreToCount | ( | size_t | count | ) |

Definition at line 319 of file canvas.cc.

319 {
320 while (GetSaveCount() > count) {
321 if (!Restore()) {
322 return;
323 }
324 }
325 }
impeller::Canvas::GetSaveCount
size_t GetSaveCount() const
Definition: canvas.cc:311

References GetSaveCount(), and Restore().

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

## ◆ Rotate()

void impeller::Canvas::Rotate | ( | Radians | radians | ) |

Definition at line 292 of file canvas.cc.

292 {
293 Concat(Matrix::MakeRotationZ(radians));
294 }
impeller::Matrix::MakeRotationZ
static Matrix MakeRotationZ(Radians r)
Definition: matrix.h:223

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

1186 {
1187 if (IsSkipping()) {
1188 return SkipUntilMatchingRestore(total_content_depth);
1189 }
1190
1191 auto entry = CanvasStackEntry{};
1192 entry.transform = transform_stack_.back().transform;
1193 entry.clip_depth = current_depth_ + total_content_depth;
1194 entry.distributed_opacity = transform_stack_.back().distributed_opacity;
1195 FML_DCHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
1196 << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
1197 << " after allocating " << total_content_depth;
1198 entry.clip_height = transform_stack_.back().clip_height;
1199 entry.rendering_mode = Entity::RenderingMode::kDirect;
1200 transform_stack_.push_back(entry);
1201 }
impeller::Entity::RenderingMode::kDirect
@ kDirect

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

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

## ◆ SaveLayer()

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

Definition at line 1240 of file canvas.cc.

1246 {
1247 TRACE_EVENT0("flutter", "Canvas::saveLayer");
1248 if (IsSkipping()) {
1249 return SkipUntilMatchingRestore(total_content_depth);
1250 }
1251
1252 auto maybe_coverage_limit = GetLocalCoverageLimit();
1253 if (!maybe_coverage_limit.has_value()) {
1254 return SkipUntilMatchingRestore(total_content_depth);
1255 }
1256 auto coverage_limit = maybe_coverage_limit.value();
1257
1258 if (can_distribute_opacity && !backdrop_filter &&
1259 Paint::CanApplyOpacityPeephole(paint) &&
1260 bounds_promise != ContentBoundsPromise::kMayClipContents) {
1261 Save(total_content_depth);
1262 transform_stack_.back().distributed_opacity *= paint.color.alpha;
1263 return;
1264 }
1265
1266 std::shared_ptr<FilterContents> filter_contents = paint.WithImageFilter(
1267 Rect(), transform_stack_.back().transform,
1268 Entity::RenderingMode::kSubpassPrependSnapshotTransform);
1269
1270 std::optional<Rect> maybe_subpass_coverage = ComputeSaveLayerCoverage(
1271 bounds.value_or(Rect::MakeMaximum()),
1272 transform_stack_.back().transform, //
1273 coverage_limit, //
1274 filter_contents, //
1275 /*flood_output_coverage=*/
1276 Entity::IsBlendModeDestructive(paint.blend_mode), //
1277 /*flood_input_coverage=*/!!backdrop_filter ||
1278 (paint.color_filter &&
1279 paint.color_filter->modifies_transparent_black()) //
1280 );
1281
1282 if (!maybe_subpass_coverage.has_value()) {
1283 return SkipUntilMatchingRestore(total_content_depth);
1284 }
1285
1286 auto subpass_coverage = maybe_subpass_coverage.value();
1287
1288 // When an image filter is present, clamp to avoid flicking due to nearest
1289 // sampled image. For other cases, round out to ensure than any geometry is
1290 // not cut off.
1291 //
1292 // See also this bug: https://github.com/flutter/flutter/issues/144213
1293 //
1294 // TODO(jonahwilliams): this could still round out for filters that use decal
1295 // sampling mode.
1296 ISize subpass_size;
1297 bool did_round_out = false;
1298 Point coverage_origin_adjustment = Point{0, 0};
1299 if (paint.image_filter) {
1300 subpass_size = ISize(subpass_coverage.GetSize());
1301 } else {
1302 did_round_out = true;
1303 subpass_size =
1304 static_cast<ISize>(IRect::RoundOut(subpass_coverage).GetSize());
1305 // If rounding out, adjust the coverage to account for the subpixel shift.
1306 coverage_origin_adjustment =
1307 Point(subpass_coverage.GetLeftTop().x -
1308 std::floor(subpass_coverage.GetLeftTop().x),
1309 subpass_coverage.GetLeftTop().y -
1310 std::floor(subpass_coverage.GetLeftTop().y));
1311 }
1312 if (subpass_size.IsEmpty()) {
1313 return SkipUntilMatchingRestore(total_content_depth);
1314 }
1315
1316 // When there are scaling filters present, these contents may exceed the
1317 // maximum texture size. Perform a clamp here, which may cause rendering
1318 // artifacts.
1319 subpass_size = subpass_size.Min(renderer_.GetContext()
1320 ->GetCapabilities()
1321 ->GetMaximumRenderPassAttachmentSize());
1322
1323 // Backdrop filter state, ignored if there is no BDF.
1324 std::shared_ptr<FilterContents> backdrop_filter_contents;
1325 Point local_position = Point(0, 0);
1326 if (backdrop_filter) {
1327 local_position = subpass_coverage.GetOrigin() - GetGlobalPassPosition();
1328 Canvas::BackdropFilterProc backdrop_filter_proc =
1329 [backdrop_filter = backdrop_filter](
1330 const FilterInput::Ref& input, const Matrix& effect_transform,
1331 Entity::RenderingMode rendering_mode) {
1332 auto filter = WrapInput(backdrop_filter, input);
1333 filter->SetEffectTransform(effect_transform);
1334 filter->SetRenderingMode(rendering_mode);
1335 return filter;
1336 };
1337
1338 std::shared_ptr<Texture> input_texture;
1339
1340 // If the backdrop ID is not nullopt and there is more than one usage
1341 // of it in the current scene, cache the backdrop texture and remove it from
1342 // the current entity pass flip.
1343 bool will_cache_backdrop_texture = false;
1344 BackdropData* backdrop_data = nullptr;
1345 // If we've reached this point, there is at least one backdrop filter. But
1346 // potentially more if there is a backdrop id. We may conditionally set this
1347 // to a higher value in the if block below.
1348 size_t backdrop_count = 1;
1349 if (backdrop_id.has_value()) {
1350 std::unordered_map<int64_t, BackdropData>::iterator backdrop_data_it =
1351 backdrop_data_.find(backdrop_id.value());
1352 if (backdrop_data_it != backdrop_data_.end()) {
1353 backdrop_data = &backdrop_data_it->second;
1354 will_cache_backdrop_texture =
1355 backdrop_data_it->second.backdrop_count > 1;
1356 backdrop_count = backdrop_data_it->second.backdrop_count;
1357 }
1358 }
1359
1360 if (!will_cache_backdrop_texture || !backdrop_data->texture_slot) {
1361 backdrop_count_ -= backdrop_count;
1362
1363 // The onscreen texture can be flipped to if:
1364 // 1. The device supports framebuffer fetch
1365 // 2. There are no more backdrop filters
1366 // 3. The current render pass is for the onscreen pass.
1367 const bool should_use_onscreen =
1368 renderer_.GetDeviceCapabilities().SupportsFramebufferFetch() &&
1369 backdrop_count_ == 0 && render_passes_.size() == 1u;
1370 input_texture = FlipBackdrop(
1371 GetGlobalPassPosition(), //
1372 /*should_remove_texture=*/will_cache_backdrop_texture, //
1373 /*should_use_onscreen=*/should_use_onscreen //
1374 );
1375 if (!input_texture) {
1376 // Validation failures are logged in FlipBackdrop.
1377 return;
1378 }
1379
1380 if (will_cache_backdrop_texture) {
1381 backdrop_data->texture_slot = input_texture;
1382 }
1383 } else {
1384 input_texture = backdrop_data->texture_slot;
1385 }
1386
1387 backdrop_filter_contents = backdrop_filter_proc(
1388 FilterInput::Make(std::move(input_texture)),
1389 transform_stack_.back().transform.Basis(),
1390 // When the subpass has a translation that means the math with
1391 // the snapshot has to be different.
1392 transform_stack_.back().transform.HasTranslation()
1393 ? Entity::RenderingMode::kSubpassPrependSnapshotTransform
1394 : Entity::RenderingMode::kSubpassAppendSnapshotTransform);
1395
1396 if (will_cache_backdrop_texture) {
1397 FML_DCHECK(backdrop_data);
1398 // If all filters on the shared backdrop layer are equal, process the
1399 // layer once.
1400 if (backdrop_data->all_filters_equal &&
1401 !backdrop_data->shared_filter_snapshot.has_value()) {
1402 // TODO(157110): compute minimum input hint.
1403 backdrop_data->shared_filter_snapshot =
1404 backdrop_filter_contents->RenderToSnapshot(renderer_, {});
1405 }
1406
1407 std::optional<Snapshot> maybe_snapshot =
1408 backdrop_data->shared_filter_snapshot;
1409 if (maybe_snapshot.has_value()) {
1410 const Snapshot& snapshot = maybe_snapshot.value();
1411 std::shared_ptr<TextureContents> contents = TextureContents::MakeRect(
1412 subpass_coverage.Shift(-GetGlobalPassPosition()));
1413 auto scaled =
1414 subpass_coverage.TransformBounds(snapshot.transform.Invert());
1415 contents->SetTexture(snapshot.texture);
1416 contents->SetSourceRect(scaled);
1417 contents->SetSamplerDescriptor(snapshot.sampler_descriptor);
1418
1419 // This backdrop entity sets a depth value as it is written to the newly
1420 // flipped backdrop and not into a new saveLayer.
1421 Entity backdrop_entity;
1422 backdrop_entity.SetContents(std::move(contents));
1423 backdrop_entity.SetClipDepth(++current_depth_);
1424 backdrop_entity.SetBlendMode(paint.blend_mode);
1425
1426 backdrop_entity.Render(renderer_, GetCurrentRenderPass());
1427 Save(0);
1428 return;
1429 }
1430 }
1431 }
1432
1433 // When applying a save layer, absorb any pending distributed opacity.
1434 Paint paint_copy = paint;
1435 paint_copy.color.alpha *= transform_stack_.back().distributed_opacity;
1436 transform_stack_.back().distributed_opacity = 1.0;
1437
1438 render_passes_.push_back(
1439 LazyRenderingConfig(renderer_, //
1440 CreateRenderTarget(renderer_, //
1441 subpass_size, //
1442 Color::BlackTransparent() //
1443 )));
1444 save_layer_state_.push_back(SaveLayerState{
1445 paint_copy, subpass_coverage.Shift(-coverage_origin_adjustment)});
1446
1447 CanvasStackEntry entry;
1448 entry.transform = transform_stack_.back().transform;
1449 entry.clip_depth = current_depth_ + total_content_depth;
1450 FML_DCHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
1451 << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
1452 << " after allocating " << total_content_depth;
1453 entry.clip_height = transform_stack_.back().clip_height;
1454 entry.rendering_mode = Entity::RenderingMode::kSubpassAppendSnapshotTransform;
1455 entry.did_round_out = did_round_out;
1456 transform_stack_.emplace_back(entry);
1457
1458 // Start non-collapsed subpasses with a fresh clip coverage stack limited by
1459 // the subpass coverage. This is important because image filters applied to
1460 // save layers may transform the subpass texture after it's rendered,
1461 // causing parent clip coverage to get misaligned with the actual area that
1462 // the subpass will affect in the parent pass.
1463 clip_coverage_stack_.PushSubpass(subpass_coverage, GetClipHeight());
1464
1465 if (!backdrop_filter_contents) {
1466 return;
1467 }
1468
1469 // Render the backdrop entity.
1470 Entity backdrop_entity;
1471 backdrop_entity.SetContents(std::move(backdrop_filter_contents));
1472 backdrop_entity.SetTransform(
1473 Matrix::MakeTranslation(Vector3(-local_position)));
1474 backdrop_entity.SetClipDepth(std::numeric_limits<uint32_t>::max());
1475 backdrop_entity.Render(renderer_, GetCurrentRenderPass());
1476 }
impeller::Canvas::GetLocalCoverageLimit
std::optional< Rect > GetLocalCoverageLimit() const
Return the culling bounds of the current render target, or nullopt if there is no coverage.
Definition: canvas.cc:1203
impeller::Canvas::BackdropFilterProc
std::function< std::shared_ptr< FilterContents >(FilterInput::Ref, const Matrix &effect_transform, Entity::RenderingMode rendering_mode)> BackdropFilterProc
Definition: canvas.h:125
impeller::Entity::RenderingMode
RenderingMode
Definition: entity.h:33
impeller::Entity::IsBlendModeDestructive
static bool IsBlendModeDestructive(BlendMode blend_mode)
Returns true if the blend mode is "destructive", meaning that even fully transparent source colors wo...
Definition: entity.cc:127
impeller::EntityPassClipStack::PushSubpass
void PushSubpass(std::optional< Rect > subpass_coverage, size_t clip_height)
Definition: entity_pass_clip_stack.cc:32
impeller::FilterInput::Ref
std::shared_ptr< FilterInput > Ref
Definition: filter_input.h:32
subpass_size
ISize subpass_size
The output size of the down-sampling pass.
Definition: gaussian_blur_filter_contents.cc:202
impeller::WrapInput
std::shared_ptr< FilterContents > WrapInput(const flutter::DlImageFilter *filter, const FilterInput::Ref &input)
Generate a new FilterContents using this filter's configuration.
Definition: image_filter.cc:18
impeller::ContentBoundsPromise::kMayClipContents
@ kMayClipContents
The caller claims the bounds are a subset of an estimate of the reasonably tight bounds but likely cl...
impeller::ComputeSaveLayerCoverage
std::optional< Rect > ComputeSaveLayerCoverage(const Rect &content_coverage, const Matrix &effect_transform, const Rect &coverage_limit, const std::shared_ptr< FilterContents > &image_filter, bool flood_output_coverage, bool flood_input_coverage)
Compute the coverage of a subpass in the global coordinate space.
Definition: save_layer_utils.cc:19
impeller::Color::BlackTransparent
static constexpr Color BlackTransparent()
Definition: color.h:270
impeller::Paint::CanApplyOpacityPeephole
static bool CanApplyOpacityPeephole(const Paint &paint)
Whether or not a save layer with the provided paint can perform the opacity peephole optimization.
Definition: paint.h:40
impeller::TRect::RoundOut
RoundOut(const TRect< U > &r)
Definition: rect.h:683
impeller::TRect< Scalar >::MakeMaximum
constexpr static TRect MakeMaximum()
Definition: rect.h:188

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

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

## ◆ Scale() [1/2]

void impeller::Canvas::Scale | ( | const Vector2 & | scale | ) |

Definition at line 280 of file canvas.cc.

280 {
281 Concat(Matrix::MakeScale(scale));
282 }
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104

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

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

## ◆ Scale() [2/2]

void impeller::Canvas::Scale | ( | const Vector3 & | scale | ) |

Definition at line 284 of file canvas.cc.

284 {
285 Concat(Matrix::MakeScale(scale));
286 }

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

## ◆ SetBackdropData()

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

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

Definition at line 1892 of file canvas.cc.

1894 {
1895 backdrop_data_ = std::move(backdrop_data);
1896 backdrop_count_ = backdrop_count;
1897 }

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

## ◆ Skew()

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

Definition at line 288 of file canvas.cc.

288 {
289 Concat(Matrix::MakeSkew(sx, sy));
290 }
impeller::Matrix::MakeSkew
static constexpr Matrix MakeSkew(Scalar sx, Scalar sy)
Definition: matrix.h:127

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

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

## ◆ SupportsBlitToOnscreen()

bool impeller::Canvas::SupportsBlitToOnscreen | ( |  | ) | const

Definition at line 2015 of file canvas.cc.

2015 {
2016 return renderer_.GetContext()
2017 ->GetCapabilities()
2018 ->SupportsTextureToTextureBlits() &&
2019 renderer_.GetContext()->GetBackendType() ==
2020 Context::BackendType::kMetal;
2021 }
impeller::Context::BackendType::kMetal
@ kMetal

## ◆ Transform()

void impeller::Canvas::Transform | ( | const Matrix & | transform | ) |

Definition at line 268 of file canvas.cc.

268 {
269 Concat(transform);
270 }

References Concat(), and transform.

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

## ◆ Translate()

void impeller::Canvas::Translate | ( | const Vector3 & | offset | ) |

Definition at line 276 of file canvas.cc.

276 {
277 Concat(Matrix::MakeTranslation(offset));
278 }

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

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

## Member Data Documentation

## ◆ kMaxDepth

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

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