#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...

Public Attributes
Color	color = Color::Black()

const flutter::DlColorSource *	color_source = nullptr

const flutter::DlColorFilter *	color_filter = nullptr

const flutter::DlImageFilter *	image_filter = nullptr

Scalar	stroke_width = 0.0

Cap	stroke_cap = Cap::kButt

Join	stroke_join = Join::kMiter

Scalar	stroke_miter = 4.0

Style	style = Style::kFill

BlendMode	blend_mode = BlendMode::kSourceOver

bool	invert_colors = false

std::optional< MaskBlurDescriptor >	mask_blur_descriptor

Detailed Description

Definition at line 26 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

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

Definition at line 35 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 27 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 31 of file paint.h.

Member Enumeration Documentation

◆ Style

enum impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 46 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 39 of file paint.h.

                                                           {
     return paint.blend_mode == BlendMode::kSourceOver &&
            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::kSourceOver, and mask_blur_descriptor.

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

◆ CreateContents()

std::shared_ptr< ColorSourceContents > impeller::Paint::CreateContents ( ) const

Definition at line 37 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;
       skia_conversions::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;
       skia_conversions::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;
       skia_conversions::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;
       skia_conversions::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());
       auto effect_transform = image_color_source->matrix();
  
       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) {
           return nullptr;
         }
         auto* image = sampler->asImage();
         if (!sampler->asImage()) {
           return nullptr;
         }
         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::TSize< Scalar >::Ceil(), color, color_filter, color_source, impeller::skia_conversions::ConvertStops(), invert_colors, impeller::ColorFilterContents::kNo, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakePointBounds(), impeller::skia_conversions::ToSamplerDescriptor(), 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 437 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 246 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 257 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 280 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 270 of file paint.cc.

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