#include <paint.h>

Classes
struct	MaskBlurDescriptor

Public Types
enum	Style { Style::kFill, Style::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< ColorFilter >	GetColorFilter () const

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

std::shared_ptr< Contents >	CreateContentsForGeometry (const std::shared_ptr< Geometry > &geometry) const

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

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

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

Public Attributes
Color	color = Color::Black()

ColorSource	color_source

bool	dither = false

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::shared_ptr< ImageFilter >	image_filter

std::shared_ptr< ColorFilter >	color_filter

std::optional< MaskBlurDescriptor >	mask_blur_descriptor

Detailed Description

Definition at line 22 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

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

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

Member Enumeration Documentation

◆ Style

enum impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 33 of file paint.h.

                    {
     kFill,
     kStroke,
   };

Member Function Documentation

◆ CreateContentsForGeometry()

std::shared_ptr< Contents > impeller::Paint::CreateContentsForGeometry ( const std::shared_ptr< Geometry > & geometry ) const

Definition at line 29 of file paint.cc.

                                                    {
   auto contents = color_source.GetContents(*this);
  
   // Attempt to apply the color filter on the CPU first.
   // Note: This is not just an optimization; some color sources rely on
   //       CPU-applied color filters to behave properly.
   auto color_filter = GetColorFilter();
   bool needs_color_filter = !!color_filter;
   if (color_filter &&
       contents->ApplyColorFilter(color_filter->GetCPUColorFilterProc())) {
     needs_color_filter = false;
   }
  
   contents->SetGeometry(geometry);
   if (mask_blur_descriptor.has_value()) {
     // If there's a mask blur and we need to apply the color filter on the GPU,
     // we need to be careful to only apply the color filter to the source
     // colors. CreateMaskBlur is able to handle this case.
     return mask_blur_descriptor->CreateMaskBlur(
         contents, needs_color_filter ? color_filter : nullptr);
   }
  
   return contents;
 }

References color_filter, color_source, GetColorFilter(), impeller::ColorSource::GetContents(), and mask_blur_descriptor.

◆ GetColorFilter()

std::shared_ptr< ColorFilter > impeller::Paint::GetColorFilter ( ) const

Definition at line 184 of file paint.cc.

                                                        {
   if (invert_colors && color_filter) {
     auto filter = ColorFilter::MakeMatrix(kColorInversion);
     return ColorFilter::MakeComposed(filter, color_filter);
   }
   if (invert_colors) {
     return ColorFilter::MakeMatrix(kColorInversion);
   }
   if (color_filter) {
     return color_filter;
   }
   return nullptr;
 }

References color_filter, invert_colors, impeller::kColorInversion, impeller::ColorFilter::MakeComposed(), and impeller::ColorFilter::MakeMatrix().

Referenced by CreateContentsForGeometry().

◆ HasColorFilter()

bool impeller::Paint::HasColorFilter ( ) const

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

Definition at line 198 of file paint.cc.

                                  {
   return !!color_filter || invert_colors;
 }

References color_filter, and invert_colors.

Referenced by impeller::Canvas::DrawImageRect(), and impeller::testing::TEST_P().

◆ 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 55 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 66 of file paint.cc.

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

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

Referenced by impeller::PaintPassDelegate::CreateContentsForSubpassTarget().

◆ WithImageFilter()

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

Definition at line 87 of file paint.cc.

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

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

Referenced by WithFilters(), WithFiltersForSubpassTarget(), and impeller::PaintPassDelegate::WithImageFilter().

◆ WithMaskBlur()

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

Definition at line 78 of file paint.cc.

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