#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< 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 >	CreateContentsForEntity (const Path &path={}, bool cover=false) const

std::shared_ptr< Contents >	CreateContentsForGeometry (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 25 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

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

Definition at line 34 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 29 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 33 of file paint.h.

Member Enumeration Documentation

◆ Style

enum impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 36 of file paint.h.

                    {
     kFill,
     kStroke,
   };

Member Function Documentation

◆ CreateContentsForEntity()

std::shared_ptr< Contents > impeller::Paint::CreateContentsForEntity	(	const Path &	path = `{}`,
		bool	cover = `false`
	)		const

Definition at line 17 of file paint.cc.

                                                                            {
   std::unique_ptr<Geometry> geometry;
   switch (style) {
     case Style::kFill:
       geometry = cover ? Geometry::MakeCover() : Geometry::MakeFillPath(path);
       break;
     case Style::kStroke:
       geometry =
           cover ? Geometry::MakeCover()
                 : Geometry::MakeStrokePath(path, stroke_width, stroke_miter,
                                            stroke_cap, stroke_join);
       break;
   }
   return CreateContentsForGeometry(std::move(geometry));
 }

References CreateContentsForGeometry(), kFill, kStroke, impeller::Geometry::MakeCover(), impeller::Geometry::MakeFillPath(), impeller::Geometry::MakeStrokePath(), stroke_cap, stroke_join, stroke_miter, stroke_width, and style.

Referenced by impeller::Canvas::DrawPaint(), and impeller::Canvas::DrawPath().

◆ CreateContentsForGeometry()

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

Definition at line 34 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.
   bool needs_color_filter = !!color_filter;
   if (color_filter &&
       contents->ApplyColorFilter(color_filter->GetCPUColorFilterProc())) {
     needs_color_filter = false;
   }
  
   contents->SetGeometry(std::move(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, impeller::ColorSource::GetContents(), and mask_blur_descriptor.

Referenced by CreateContentsForEntity(), impeller::Canvas::DrawPoints(), impeller::Canvas::DrawRect(), impeller::Canvas::DrawRRect(), and impeller::Canvas::DrawVertices().

◆ HasColorFilter()

bool impeller::Paint::HasColorFilter ( ) const

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

Definition at line 211 of file paint.cc.

                                  {
   return !!color_filter;
 }

References color_filter.

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 59 of file paint.cc.

                                          {
   input = WithColorFilter(input, ColorFilterContents::AbsorbOpacity::kYes);
   input = WithInvertFilter(input);
   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::DrawPath(), impeller::Canvas::DrawPoints(), impeller::Canvas::DrawRect(), impeller::Canvas::DrawRRect(), 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 71 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 92 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 83 of file paint.cc.

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