impeller::Paint::MaskBlurDescriptor Struct Reference

#include <paint.h>

Public Member Functions
std::shared_ptr< FilterContents >	CreateMaskBlur (std::shared_ptr< ColorSourceContents > color_source_contents, const std::shared_ptr< ColorFilter > &color_filter) const
std::shared_ptr< FilterContents >	CreateMaskBlur (std::shared_ptr< TextureContents > texture_contents) const
std::shared_ptr< FilterContents >	CreateMaskBlur (const FilterInput::Ref &input, bool is_solid_color) const

Public Attributes
FilterContents::BlurStyle	style
Sigma	sigma

Detailed Description

Definition at line 39 of file paint.h.

Member Function Documentation

CreateMaskBlur() [1/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur	(	const FilterInput::Ref &	input,
		bool	is_solid_color
	)		const

Definition at line 203 of file paint.cc.

                               {
  if (is_solid_color) {
    return FilterContents::MakeGaussianBlur(input, sigma, sigma,
                                            Entity::TileMode::kDecal, style);
  }
  return FilterContents::MakeBorderMaskBlur(input, sigma, sigma, style);
}

CreateMaskBlur() [2/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur	(	std::shared_ptr< ColorSourceContents >	color_source_contents,
		const std::shared_ptr< ColorFilter > &	color_filter
	)		const

1. Create an opaque white mask of the original geometry.

1. Blur the mask.

1. Replace the geometry of the original color source with a rectangle that covers the full region of the blurred mask. Note that geometry is in local bounds.

1. Apply the user set color filter on the GPU, if applicable.

1. Composite the color source with the blurred mask.

Definition at line 153 of file paint.cc.

                                                          {
  // If it's a solid color and there is no color filter, then we can just get
  // away with doing one Gaussian blur.
  if (color_source_contents->IsSolidColor() && !color_filter) {
    return FilterContents::MakeGaussianBlur(
        FilterInput::Make(color_source_contents), sigma, sigma,
        Entity::TileMode::kDecal, style, color_source_contents->GetGeometry());
  }
 
  /// 1. Create an opaque white mask of the original geometry.
 
  auto mask = std::make_shared<SolidColorContents>();
  mask->SetColor(Color::White());
  mask->SetGeometry(color_source_contents->GetGeometry());
 
  /// 2. Blur the mask.
 
  auto blurred_mask = FilterContents::MakeGaussianBlur(
      FilterInput::Make(mask), sigma, sigma, Entity::TileMode::kDecal, style,
      color_source_contents->GetGeometry());
 
  /// 3. Replace the geometry of the original color source with a rectangle that
  ///    covers the full region of the blurred mask. Note that geometry is in
  ///    local bounds.
 
  auto expanded_local_bounds = blurred_mask->GetCoverage({});
  if (!expanded_local_bounds.has_value()) {
    expanded_local_bounds = Rect();
  }
  color_source_contents->SetGeometry(
      Geometry::MakeRect(*expanded_local_bounds));
  std::shared_ptr<Contents> color_contents = color_source_contents;
 
  /// 4. Apply the user set color filter on the GPU, if applicable.
 
  if (color_filter) {
    color_contents = color_filter->WrapWithGPUColorFilter(
        FilterInput::Make(color_source_contents),
        ColorFilterContents::AbsorbOpacity::kYes);
  }
 
  /// 5. Composite the color source with the blurred mask.
 
  return ColorFilterContents::MakeBlend(
      BlendMode::kSourceIn,
      {FilterInput::Make(blurred_mask), FilterInput::Make(color_contents)});
}

CreateMaskBlur() [3/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur

(

std::shared_ptr< TextureContents >

texture_contents

)

const

Definition at line 125 of file paint.cc.

                                                           {
  Scalar expand_amount = GaussianBlurFilterContents::CalculateBlurRadius(
      GaussianBlurFilterContents::ScaleSigma(sigma.sigma));
  texture_contents->SetSourceRect(
      texture_contents->GetSourceRect().Expand(expand_amount, expand_amount));
  auto mask = std::make_shared<SolidColorContents>();
  mask->SetColor(Color::White());
  std::optional<Rect> coverage = texture_contents->GetCoverage({});
  std::shared_ptr<Geometry> geometry;
  if (coverage) {
    texture_contents->SetDestinationRect(
        coverage.value().Expand(expand_amount, expand_amount));
    geometry = Geometry::MakeRect(coverage.value());
  }
  mask->SetGeometry(geometry);
  auto descriptor = texture_contents->GetSamplerDescriptor();
  texture_contents->SetSamplerDescriptor(descriptor);
  std::shared_ptr<FilterContents> blurred_mask =
      FilterContents::MakeGaussianBlur(FilterInput::Make(mask), sigma, sigma,
                                       Entity::TileMode::kDecal, style,
                                       geometry);
 
  return ColorFilterContents::MakeBlend(
      BlendMode::kSourceIn,
      {FilterInput::Make(blurred_mask), FilterInput::Make(texture_contents)});
}

Member Data Documentation

sigma

Sigma impeller::Paint::MaskBlurDescriptor::sigma

Definition at line 41 of file paint.h.

style

FilterContents::BlurStyle impeller::Paint::MaskBlurDescriptor::style

Definition at line 40 of file paint.h.

---

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

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