#include <paint.h>

Classes
struct	MaskBlurDescriptor

Public Types
enum class	Style { kFill , kStroke }

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

using	MaskFilterProc = std::function< std::shared_ptr< FilterContents >(FilterInput::Ref, bool is_solid_color, const Matrix &effect_transform)>

using	ColorSourceProc = std::function< std::shared_ptr< ColorSourceContents >()>

Public Member Functions
std::optional< StrokeParameters >	GetStroke () const
	Return an optional StrokeParameters if this Paint is a stroked Paint, otherwise return a nullopt. More...

std::shared_ptr< Contents >	WithFilters (const ContentContext &renderer, std::shared_ptr< Contents > input) const
	Wrap this paint's configured filters to the given contents. More...

std::shared_ptr< Contents >	WithFiltersForSubpassTarget (const ContentContext &renderer, std::shared_ptr< Contents > input, const Matrix &effect_transform=Matrix()) const
	Wrap this paint's configured filters to the given contents of subpass target. More...

bool	HasColorFilter () const
	Whether this paint has a color filter that can apply opacity. More...

std::shared_ptr< ColorSourceContents >	CreateContents (const ContentContext &renderer, const Geometry *geometry, const std::optional< Matrix > &geometry_transform=std::nullopt) const
	Create a `ColorSourceContents` representing this paint's shader/colors. More...

std::shared_ptr< Contents >	WithMaskBlur (std::shared_ptr< Contents > input, bool is_solid_color, const Matrix &ctm) const

std::shared_ptr< FilterContents >	WithImageFilter (const ContentContext &renderer, const FilterInput::Variant &input, const Matrix &effect_transform, Entity::RenderingMode rendering_mode) const

Static Public Member Functions
static bool	CanApplyOpacityPeephole (const Paint &paint)
	Whether or not a save layer with the provided paint can perform the opacity peephole optimization. More...

static void	ConvertStops (const flutter::DlGradientColorSourceBase *gradient, std::vector< Color > &colors, std::vector< float > &stops)
	Convert display list colors + stops into impeller colors and stops, taking care to ensure that the stops monotonically increase from 0.0 to 1.0. More...

Public Attributes
Color	color = Color::Black()

const flutter::DlColorSource *	color_source = nullptr

const flutter::DlColorFilter *	color_filter = nullptr

const flutter::DlImageFilter *	image_filter = nullptr

StrokeParameters	stroke

Style	style = Style::kFill

BlendMode	blend_mode = BlendMode::kSrcOver

bool	invert_colors = false

bool	anti_alias = true

std::optional< MaskBlurDescriptor >	mask_blur_descriptor

Detailed Description

Definition at line 29 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

using impeller::Paint::ColorSourceProc = std::function<std::shared_ptr<ColorSourceContents>()>

Definition at line 38 of file paint.h.

◆ ImageFilterProc

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

Definition at line 30 of file paint.h.

◆ MaskFilterProc

using impeller::Paint::MaskFilterProc = std::function<std::shared_ptr<FilterContents>( FilterInput::Ref, bool is_solid_color, const Matrix& effect_transform)>

Definition at line 34 of file paint.h.

Member Enumeration Documentation

◆ Style

enum impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 49 of file paint.h.

                    {
     kFill,
     kStroke,
   };

Member Function Documentation

◆ CanApplyOpacityPeephole()

static bool impeller::Paint::CanApplyOpacityPeephole ( const Paint & paint )

inlinestatic

Whether or not a save layer with the provided paint can perform the opacity peephole optimization.

Definition at line 42 of file paint.h.

                                                           {
     return paint.blend_mode == BlendMode::kSrcOver &&
            paint.invert_colors == false &&
            !paint.mask_blur_descriptor.has_value() &&
            paint.image_filter == nullptr && paint.color_filter == nullptr;
   }

References blend_mode, color_filter, image_filter, invert_colors, impeller::kSrcOver, and mask_blur_descriptor.

Referenced by impeller::Canvas::SaveLayer().

◆ ConvertStops()

void impeller::Paint::ConvertStops	(	const flutter::DlGradientColorSourceBase *	gradient,
		std::vector< Color > &	colors,
		std::vector< float > &	stops
	)

static

Convert display list colors + stops into impeller colors and stops, taking care to ensure that the stops monotonically increase from 0.0 to 1.0.

The general process is:

Ensure that the first gradient stop value is 0.0. If not, insert a new stop with a value of 0.0 and use the first gradient color as this new stops color.
Ensure the last gradient stop value is 1.0. If not, insert a new stop with a value of 1.0 and use the last gradient color as this stops color.
Clamp all gradient values between the values of 0.0 and 1.0.
For all stop values, ensure that the values are monotonically increasing by clamping each value to a minimum of the previous stop value and itself. For example, with stop values of 0.0, 0.5, 0.4, 1.0, we would clamp such that the values were 0.0, 0.5, 0.5, 1.0.

Definition at line 39 of file paint.cc.

                                                   {
   FML_DCHECK(gradient->stop_count() >= 2)
       << "stop_count:" << gradient->stop_count();
  
   auto* dl_colors = gradient->colors();
   auto* dl_stops = gradient->stops();
   if (dl_stops[0] != 0.0) {
     colors.emplace_back(skia_conversions::ToColor(dl_colors[0]));
     stops.emplace_back(0);
   }
   for (auto i = 0; i < gradient->stop_count(); i++) {
     colors.emplace_back(skia_conversions::ToColor(dl_colors[i]));
     stops.emplace_back(std::clamp(dl_stops[i], 0.0f, 1.0f));
   }
   if (dl_stops[gradient->stop_count() - 1] != 1.0) {
     colors.emplace_back(colors.back());
     stops.emplace_back(1.0);
   }
   for (auto i = 1; i < gradient->stop_count(); i++) {
     stops[i] = std::clamp(stops[i], stops[i - 1], stops[i]);
   }
 }

References impeller::skia_conversions::ToColor().

Referenced by CreateContents(), and impeller::testing::TEST().

◆ CreateContents()

std::shared_ptr< ColorSourceContents > impeller::Paint::CreateContents	(	const ContentContext &	renderer,
		const Geometry *	geometry,
		const std::optional< Matrix > &	geometry_transform = `std::nullopt`
	)		const

Create a ColorSourceContents representing this paint's shader/colors.

Parameters

[in]	renderer	The content context renderer.
[in]	geometry	The geometry the color source is drawn onto.
[in]	geometry_transform	An optional transform representing a layout/positioning transform applied to the geometry. If provided, this is used to adjust the color source's effect transform to align it with the geometry's coordinate space.

Returns: The generated color source contents.

Definition at line 64 of file paint.cc.

                                                          {
   if (color_source == nullptr) {
     auto contents = std::make_shared<SolidColorContents>(geometry);
     contents->SetColor(color);
     return contents;
   }
  
   Matrix inverted_geometry_transform =
       geometry_transform.has_value() ? geometry_transform->Invert() : Matrix();
  
   switch (color_source->type()) {
     case flutter::DlColorSourceType::kLinearGradient: {
       const flutter::DlLinearGradientColorSource* linear =
           color_source->asLinearGradient();
       FML_DCHECK(linear);
       auto start_point = linear->start_point();
       auto end_point = linear->end_point();
       std::vector<Color> colors;
       std::vector<float> stops;
       ConvertStops(linear, colors, stops);
  
       auto tile_mode = static_cast<Entity::TileMode>(linear->tile_mode());
       auto effect_transform = linear->matrix();
  
       auto contents = std::make_shared<LinearGradientContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetEndPoints(start_point, end_point);
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(inverted_geometry_transform *
                                    effect_transform);
  
       std::array<Point, 2> bounds{start_point, end_point};
       auto intrinsic_size = Rect::MakePointBounds(bounds.begin(), bounds.end());
       if (intrinsic_size.has_value()) {
         contents->SetColorSourceSize(intrinsic_size->GetSize().Max({1, 1}));
       }
       return contents;
     }
     case flutter::DlColorSourceType::kRadialGradient: {
       const flutter::DlRadialGradientColorSource* radialGradient =
           color_source->asRadialGradient();
       FML_DCHECK(radialGradient);
       auto center = radialGradient->center();
       auto radius = radialGradient->radius();
       std::vector<Color> colors;
       std::vector<float> stops;
       ConvertStops(radialGradient, colors, stops);
  
       auto tile_mode =
           static_cast<Entity::TileMode>(radialGradient->tile_mode());
       auto effect_transform = radialGradient->matrix();
  
       auto contents = std::make_shared<RadialGradientContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetCenterAndRadius(center, radius);
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(inverted_geometry_transform *
                                    effect_transform);
  
       auto intrinsic_size = Rect::MakeCircleBounds(center, std::abs(radius));
       contents->SetColorSourceSize(intrinsic_size.GetSize().Max({1, 1}));
       return contents;
     }
     case flutter::DlColorSourceType::kConicalGradient: {
       const flutter::DlConicalGradientColorSource* conical_gradient =
           color_source->asConicalGradient();
       FML_DCHECK(conical_gradient);
       Point center = conical_gradient->end_center();
       DlScalar radius = conical_gradient->end_radius();
       Point focus_center = conical_gradient->start_center();
       DlScalar focus_radius = conical_gradient->start_radius();
       std::vector<Color> colors;
       std::vector<float> stops;
       ConvertStops(conical_gradient, colors, stops);
  
       auto tile_mode =
           static_cast<Entity::TileMode>(conical_gradient->tile_mode());
       auto effect_transform = conical_gradient->matrix();
  
       auto contents = std::make_shared<ConicalGradientContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetCenterAndRadius(center, radius);
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(inverted_geometry_transform *
                                    effect_transform);
       contents->SetFocus(focus_center, focus_radius);
  
       auto intrinsic_size = Rect::MakeCircleBounds(center, std::abs(radius));
       contents->SetColorSourceSize(intrinsic_size.GetSize().Max({1, 1}));
       return contents;
     }
     case flutter::DlColorSourceType::kSweepGradient: {
       const flutter::DlSweepGradientColorSource* sweepGradient =
           color_source->asSweepGradient();
       FML_DCHECK(sweepGradient);
  
       auto center = sweepGradient->center();
       auto start_angle = Degrees(sweepGradient->start());
       auto end_angle = Degrees(sweepGradient->end());
       std::vector<Color> colors;
       std::vector<float> stops;
       ConvertStops(sweepGradient, colors, stops);
  
       auto tile_mode =
           static_cast<Entity::TileMode>(sweepGradient->tile_mode());
       auto effect_transform = sweepGradient->matrix();
  
       auto contents = std::make_shared<SweepGradientContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetCenterAndAngles(center, start_angle, end_angle);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(inverted_geometry_transform *
                                    effect_transform);
  
       return contents;
     }
     case flutter::DlColorSourceType::kImage: {
       const flutter::DlImageColorSource* image_color_source =
           color_source->asImage();
       FML_DCHECK(image_color_source);
       auto texture =
           image_color_source->image()->asImpellerImage()->GetCachedTexture(
               renderer);
       FML_DCHECK(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());
       // See https://github.com/flutter/flutter/issues/165205
       flutter::DlMatrix effect_transform = image_color_source->matrix().To3x3();
  
       auto contents = std::make_shared<TiledTextureContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetTexture(texture);
       contents->SetTileModes(x_tile_mode, y_tile_mode);
       contents->SetSamplerDescriptor(sampler_descriptor);
       contents->SetEffectTransform(inverted_geometry_transform *
                                    effect_transform);
       if (color_filter || invert_colors) {
         TiledTextureContents::ColorFilterProc filter_proc =
             [color_filter = color_filter,
              invert_colors = invert_colors](const FilterInput::Ref& input) {
               if (invert_colors && color_filter) {
                 std::shared_ptr<FilterContents> color_filter_output =
                     WrapWithGPUColorFilter(
                         color_filter, input,
                         ColorFilterContents::AbsorbOpacity::kNo);
                 return WrapWithInvertColors(
                     FilterInput::Make(color_filter_output),
                     ColorFilterContents::AbsorbOpacity::kNo);
               }
               if (color_filter) {
                 return WrapWithGPUColorFilter(
                     color_filter, input,
                     ColorFilterContents::AbsorbOpacity::kNo);
               }
               return WrapWithInvertColors(
                   input, ColorFilterContents::AbsorbOpacity::kNo);
             };
         contents->SetColorFilter(filter_proc);
       }
       contents->SetColorSourceSize(Size::Ceil(texture->GetSize()));
       return contents;
     }
     case flutter::DlColorSourceType::kRuntimeEffect: {
       const flutter::DlRuntimeEffectColorSource* runtime_effect_color_source =
           color_source->asRuntimeEffect();
       auto runtime_stage =
           runtime_effect_color_source->runtime_effect()->runtime_stage();
       auto uniform_data = runtime_effect_color_source->uniform_data();
       auto samplers = runtime_effect_color_source->samplers();
  
       std::vector<RuntimeEffectContents::TextureInput> texture_inputs;
  
       for (auto& sampler : samplers) {
         if (sampler == nullptr) {
           VALIDATION_LOG << "Runtime effect sampler is null";
           auto contents = std::make_shared<SolidColorContents>(geometry);
           contents->SetColor(Color::BlackTransparent());
           return contents;
         }
         auto* image = sampler->asImage();
         if (!sampler->asImage()) {
           VALIDATION_LOG << "Runtime effect sampler is not an image";
           auto contents = std::make_shared<SolidColorContents>(geometry);
           contents->SetColor(Color::BlackTransparent());
           return contents;
         }
         auto texture =
             image->image()->asImpellerImage()->GetCachedTexture(renderer);
         FML_DCHECK(texture);
         texture_inputs.push_back({
             .sampler_descriptor =
                 skia_conversions::ToSamplerDescriptor(image->sampling()),
             .texture = std::move(texture),
         });
       }
  
       auto contents = std::make_shared<RuntimeEffectContents>(geometry);
       contents->SetOpacityFactor(color.alpha);
       contents->SetRuntimeStage(std::move(runtime_stage));
       contents->SetUniformData(std::move(uniform_data));
       contents->SetTextureInputs(std::move(texture_inputs));
       return contents;
     }
   }
   FML_UNREACHABLE();
 }

References impeller::Color::alpha, impeller::Color::BlackTransparent(), impeller::TSize< Scalar >::Ceil(), color, color_filter, color_source, ConvertStops(), impeller::Matrix::Invert(), invert_colors, impeller::ColorFilterContents::kNo, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeCircleBounds(), impeller::TRect< Scalar >::MakePointBounds(), impeller::skia_conversions::ToSamplerDescriptor(), VALIDATION_LOG, impeller::WrapWithGPUColorFilter(), and impeller::WrapWithInvertColors().

Referenced by impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), and impeller::Canvas::DrawRoundSuperellipse().

◆ GetStroke()

std::optional<StrokeParameters> impeller::Paint::GetStroke ( ) const

inline

Return an optional StrokeParameters if this Paint is a stroked Paint, otherwise return a nullopt.

Returns: An optional set of StrokeParameters

Definition at line 95 of file paint.h.

                                                   {
     return (style == Style::kStroke) ? std::optional(stroke) : std::nullopt;
   }

References kStroke, stroke, and style.

Referenced by impeller::Canvas::DrawCircle(), impeller::Canvas::DrawRect(), impeller::Canvas::DrawRoundSuperellipse(), impeller::FirstPassDispatcher::drawText(), impeller::Canvas::DrawTextFrame(), and impeller::testing::TEST().

◆ HasColorFilter()

bool impeller::Paint::HasColorFilter ( ) const

Whether this paint has a color filter that can apply opacity.

Definition at line 480 of file paint.cc.

                                  {
   return color_filter || invert_colors;
 }

Referenced by impeller::Canvas::DrawImageRect().

◆ WithFilters()

std::shared_ptr< Contents > impeller::Paint::WithFilters	(	const ContentContext &	renderer,
		std::shared_ptr< Contents >	input
	)		const

Wrap this paint's configured filters to the given contents.

Parameters

[in] input The contents to wrap with paint's filters.

Returns: The filter-wrapped contents. If there are no filters that need to be wrapped for the current paint configuration, the original contents is returned.

Definition at line 286 of file paint.cc.

                                          {
   input = WithColorFilter(input, ColorFilterContents::AbsorbOpacity::kYes);
   auto image_filter = WithImageFilter(renderer, input, Matrix(),
                                       Entity::RenderingMode::kDirect);
   if (image_filter) {
     input = image_filter;
   }
   return input;
 }

References image_filter, impeller::Entity::kDirect, impeller::ColorFilterContents::kYes, and WithImageFilter().

Referenced by impeller::Canvas::DrawAtlas(), impeller::Canvas::DrawImageRect(), impeller::Canvas::DrawTextFrame(), and impeller::Canvas::DrawVertices().

◆ WithFiltersForSubpassTarget()

std::shared_ptr< Contents > impeller::Paint::WithFiltersForSubpassTarget	(	const ContentContext &	renderer,
		std::shared_ptr< Contents >	input,
		const Matrix &	effect_transform = `Matrix()`
	)		const

Wrap this paint's configured filters to the given contents of subpass target.

Parameters

[in] input The contents of subpass target to wrap with paint's filters.

Returns: The filter-wrapped contents. If there are no filters that need to be wrapped for the current paint configuration, the original contents is returned.

Definition at line 298 of file paint.cc.

                                           {
   auto image_filter =
       WithImageFilter(renderer, input, effect_transform,
                       Entity::RenderingMode::kSubpassPrependSnapshotTransform);
   if (image_filter) {
     input = image_filter;
   }
   input = WithColorFilter(input, ColorFilterContents::AbsorbOpacity::kYes);
   return input;
 }

References image_filter, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::ColorFilterContents::kYes, and WithImageFilter().

◆ WithImageFilter()

std::shared_ptr< FilterContents > impeller::Paint::WithImageFilter	(	const ContentContext &	renderer,
		const FilterInput::Variant &	input,
		const Matrix &	effect_transform,
		Entity::RenderingMode	rendering_mode
	)		const

Definition at line 322 of file paint.cc.

                                               {
   if (!image_filter) {
     return nullptr;
   }
   auto filter = WrapInput(renderer, image_filter, FilterInput::Make(input));
   filter->SetRenderingMode(rendering_mode);
   filter->SetEffectTransform(effect_transform);
   return filter;
 }

References image_filter, impeller::FilterInput::Make(), and impeller::WrapInput().

Referenced by impeller::Canvas::SaveLayer(), WithFilters(), and WithFiltersForSubpassTarget().

◆ WithMaskBlur()

std::shared_ptr< Contents > impeller::Paint::WithMaskBlur	(	std::shared_ptr< Contents >	input,
		bool	is_solid_color,
		const Matrix &	ctm
	)		const

Definition at line 312 of file paint.cc.

                                                                        {
   if (mask_blur_descriptor.has_value()) {
     input = mask_blur_descriptor->CreateMaskBlur(FilterInput::Make(input),
                                                  is_solid_color, ctm);
   }
   return input;
 }

References impeller::FilterInput::Make(), and mask_blur_descriptor.

Member Data Documentation

◆ anti_alias

bool impeller::Paint::anti_alias = true

Definition at line 88 of file paint.h.

Referenced by impeller::Canvas::IsCompatibleWithSDFRendering(), impeller::DlDispatcherBase::setAntiAlias(), and impeller::testing::TEST().

◆ blend_mode

BlendMode impeller::Paint::blend_mode = BlendMode::kSrcOver

Definition at line 86 of file paint.h.

◆ color

◆ color_filter

const flutter::DlColorFilter* impeller::Paint::color_filter = nullptr

Definition at line 81 of file paint.h.

Referenced by CanApplyOpacityPeephole(), CreateContents(), impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), impeller::Canvas::SaveLayer(), and impeller::DlDispatcherBase::setColorFilter().

◆ color_source

const flutter::DlColorSource* impeller::Paint::color_source = nullptr

Definition at line 80 of file paint.h.

Referenced by CreateContents(), impeller::Canvas::DrawRoundSuperellipse(), impeller::Canvas::DrawVertices(), impeller::DlDispatcherBase::setColorSource(), and impeller::testing::TEST_P().

◆ image_filter

const flutter::DlImageFilter* impeller::Paint::image_filter = nullptr

Definition at line 82 of file paint.h.

Referenced by CanApplyOpacityPeephole(), impeller::Canvas::SaveLayer(), impeller::DlDispatcherBase::setImageFilter(), WithFilters(), WithFiltersForSubpassTarget(), and WithImageFilter().

◆ invert_colors

bool impeller::Paint::invert_colors = false

Definition at line 87 of file paint.h.

Referenced by CanApplyOpacityPeephole(), CreateContents(), impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), and impeller::DlDispatcherBase::setInvertColors().

◆ mask_blur_descriptor

std::optional<MaskBlurDescriptor> impeller::Paint::mask_blur_descriptor

Definition at line 90 of file paint.h.

Referenced by CanApplyOpacityPeephole(), impeller::Canvas::DrawImageRect(), impeller::DlDispatcherBase::drawShadow(), impeller::Canvas::DrawTextFrame(), impeller::Canvas::IsCompatibleWithSDFRendering(), impeller::DlDispatcherBase::setMaskFilter(), and WithMaskBlur().

◆ stroke

StrokeParameters impeller::Paint::stroke

Definition at line 84 of file paint.h.

◆ style

Style impeller::Paint::style = Style::kFill

Definition at line 85 of file paint.h.

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

impeller/display_list/paint.h
impeller/display_list/paint.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ ColorSourceProc

◆ ImageFilterProc

◆ MaskFilterProc

Member Enumeration Documentation

◆ Style

Member Function Documentation

◆ CanApplyOpacityPeephole()

◆ ConvertStops()

◆ CreateContents()

◆ GetStroke()

◆ HasColorFilter()

◆ WithFilters()

◆ WithFiltersForSubpassTarget()

◆ WithImageFilter()

◆ WithMaskBlur()

Member Data Documentation

◆ anti_alias

◆ blend_mode

◆ color

◆ color_filter

◆ color_source

◆ image_filter

◆ invert_colors

◆ mask_blur_descriptor

◆ stroke

◆ style