#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::shared_ptr< Contents >	WithFilters (std::shared_ptr< Contents > input) const
	Wrap this paint's configured filters to the given contents. More...

std::shared_ptr< Contents >	WithFiltersForSubpassTarget (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

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

std::shared_ptr< FilterContents >	WithImageFilter (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

std::optional< MaskBlurDescriptor >	mask_blur_descriptor

Detailed Description

Definition at line 27 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

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

Definition at line 36 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 28 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 32 of file paint.h.

Member Enumeration Documentation

◆ Style

enum impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 47 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 40 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 37 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

Definition at line 62 of file paint.cc.

                                                                {
   if (color_source == nullptr) {
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetColor(color);
     return contents;
   }
  
   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>();
       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(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>();
       contents->SetOpacityFactor(color.alpha);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetCenterAndRadius(center, radius);
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(effect_transform);
  
       auto radius_pt = Point(radius, radius);
       std::array<Point, 2> bounds{center + radius_pt, center - radius_pt};
       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::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();
  
       std::shared_ptr<ConicalGradientContents> contents =
           std::make_shared<ConicalGradientContents>();
       contents->SetOpacityFactor(color.alpha);
       contents->SetColors(std::move(colors));
       contents->SetStops(std::move(stops));
       contents->SetCenterAndRadius(center, radius);
       contents->SetTileMode(tile_mode);
       contents->SetEffectTransform(effect_transform);
       contents->SetFocus(focus_center, focus_radius);
  
       auto radius_pt = Point(radius, radius);
       std::array<Point, 2> bounds{center + radius_pt, center - radius_pt};
       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::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>();
       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(effect_transform);
  
       return contents;
     }
     case flutter::DlColorSourceType::kImage: {
       const flutter::DlImageColorSource* image_color_source =
           color_source->asImage();
       FML_DCHECK(image_color_source &&
                  image_color_source->image()->impeller_texture());
       auto texture = image_color_source->image()->impeller_texture();
       auto x_tile_mode = static_cast<Entity::TileMode>(
           image_color_source->horizontal_tile_mode());
       auto y_tile_mode = static_cast<Entity::TileMode>(
           image_color_source->vertical_tile_mode());
       auto sampler_descriptor =
           skia_conversions::ToSamplerDescriptor(image_color_source->sampling());
       // See https://github.com/flutter/flutter/issues/165205
       flutter::DlMatrix effect_transform = image_color_source->matrix().To3x3();
  
       auto contents = std::make_shared<TiledTextureContents>();
       contents->SetOpacityFactor(color.alpha);
       contents->SetTexture(texture);
       contents->SetTileModes(x_tile_mode, y_tile_mode);
       contents->SetSamplerDescriptor(sampler_descriptor);
       contents->SetEffectTransform(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>();
           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>();
           contents->SetColor(Color::BlackTransparent());
           return contents;
         }
         FML_DCHECK(image->image()->impeller_texture());
         texture_inputs.push_back({
             .sampler_descriptor =
                 skia_conversions::ToSamplerDescriptor(image->sampling()),
             .texture = image->image()->impeller_texture(),
         });
       }
  
       auto contents = std::make_shared<RuntimeEffectContents>();
       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(), invert_colors, impeller::ColorFilterContents::kNo, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakePointBounds(), impeller::skia_conversions::ToSamplerDescriptor(), VALIDATION_LOG, impeller::WrapWithGPUColorFilter(), and impeller::WrapWithInvertColors().

◆ HasColorFilter()

bool impeller::Paint::HasColorFilter ( ) const

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

Definition at line 469 of file paint.cc.

                                  {
   return color_filter || invert_colors;
 }

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

◆ WithFilters()

std::shared_ptr< Contents > impeller::Paint::WithFilters ( 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 278 of file paint.cc.

                                          {
   input = WithColorFilter(input, ColorFilterContents::AbsorbOpacity::kYes);
   auto image_filter =
       WithImageFilter(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	(	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 289 of file paint.cc.

                                           {
   auto image_filter =
       WithImageFilter(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 FilterInput::Variant &	input,
		const Matrix &	effect_transform,
		Entity::RenderingMode	rendering_mode
	)		const

Definition at line 312 of file paint.cc.

                                               {
   if (!image_filter) {
     return nullptr;
   }
   auto filter = WrapInput(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 302 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

◆ blend_mode

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

◆ color

Color impeller::Paint::color = Color::Black()

Definition at line 75 of file paint.h.

Referenced by CreateContents(), impeller::Canvas::DrawAtlas(), impeller::DlDispatcherBase::drawColor(), impeller::DlDispatcherBase::drawDisplayList(), impeller::Canvas::DrawImageRect(), impeller::Canvas::DrawLine(), impeller::DlDispatcherBase::drawShadow(), impeller::FirstPassDispatcher::drawTextFrame(), impeller::Canvas::DrawTextFrame(), impeller::Canvas::DrawVertices(), impeller::Canvas::SaveLayer(), impeller::DlDispatcherBase::setColor(), impeller::FirstPassDispatcher::setColor(), and impeller::testing::TEST_P().

◆ color_filter

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

Definition at line 77 of file paint.h.

Referenced by CanApplyOpacityPeephole(), CreateContents(), impeller::Canvas::DrawLine(), impeller::Canvas::SaveLayer(), and impeller::DlDispatcherBase::setColorFilter().

◆ color_source

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

Definition at line 76 of file paint.h.

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

◆ image_filter

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

Definition at line 78 of file paint.h.

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

◆ invert_colors

bool impeller::Paint::invert_colors = false

Definition at line 83 of file paint.h.

Referenced by CanApplyOpacityPeephole(), CreateContents(), impeller::Canvas::DrawLine(), and impeller::DlDispatcherBase::setInvertColors().

◆ mask_blur_descriptor

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

Definition at line 85 of file paint.h.

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

◆ stroke

StrokeParameters impeller::Paint::stroke

Definition at line 80 of file paint.h.

◆ style

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

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