#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< 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 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()

ColorSource	color_source

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 23 of file paint.h.

Member Typedef Documentation

◆ ColorSourceProc

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

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

Member Enumeration Documentation

◆ Style

enum class impeller::Paint::Style

strong

Enumerator
kFill
kStroke

Definition at line 43 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 36 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;
  }

◆ CreateContentsForGeometry()

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

Definition at line 30 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;
}

◆ GetColorFilter()

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

Definition at line 222 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;
}

◆ HasColorFilter()

bool Paint::HasColorFilter ( ) const

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

Definition at line 236 of file paint.cc.

                                 {
  return !!color_filter || invert_colors;
}

◆ WithFilters()

std::shared_ptr< Contents > 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 56 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;
}

◆ WithFiltersForSubpassTarget()

std::shared_ptr< Contents > 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 67 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;
}

◆ WithImageFilter()

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

Definition at line 90 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;
}

◆ WithMaskBlur()

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

Definition at line 80 of file paint.cc.

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

Member Data Documentation

◆ blend_mode

BlendMode impeller::Paint::blend_mode = BlendMode::kSourceOver

Definition at line 76 of file paint.h.

◆ color

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

Definition at line 68 of file paint.h.

◆ color_filter

std::shared_ptr<ColorFilter> impeller::Paint::color_filter

Definition at line 80 of file paint.h.

◆ color_source

ColorSource impeller::Paint::color_source

Definition at line 69 of file paint.h.

◆ image_filter

std::shared_ptr<ImageFilter> impeller::Paint::image_filter

Definition at line 79 of file paint.h.

◆ invert_colors

bool impeller::Paint::invert_colors = false

Definition at line 77 of file paint.h.

◆ mask_blur_descriptor

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

Definition at line 81 of file paint.h.

◆ stroke_cap

Cap impeller::Paint::stroke_cap = Cap::kButt

Definition at line 72 of file paint.h.

◆ stroke_join

Join impeller::Paint::stroke_join = Join::kMiter

Definition at line 73 of file paint.h.

◆ stroke_miter

Scalar impeller::Paint::stroke_miter = 4.0

Definition at line 74 of file paint.h.

◆ stroke_width

Scalar impeller::Paint::stroke_width = 0.0

Definition at line 71 of file paint.h.

◆ style

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

Definition at line 75 of file paint.h.

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

impeller/aiks/paint.h
impeller/aiks/paint.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes