| Flutter Impeller |

Public Member Functions | Public Attributes | List of all members
impeller::Paint::MaskBlurDescriptor Struct Reference

`#include <paint.h>`

## Public Member Functions
std::shared_ptr< FilterContents > | CreateMaskBlur (std::shared_ptr< ColorSourceContents > color_source_contents, const flutter::DlColorFilter *color_filter, bool invert_colors, RectGeometry *rect_geom) const
std::shared_ptr< FilterContents > | CreateMaskBlur (std::shared_ptr< TextureContents > texture_contents, RectGeometry *rect_geom) const
std::shared_ptr< FilterContents > | CreateMaskBlur (const FilterInput::Ref &input, bool is_solid_color, const Matrix &ctm) const

## Public Attributes
FilterContents::BlurStyle | style
Sigma | sigma
bool | respect_ctm = true

## Detailed Description

Definition at line 51 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 Matrix & | ctm
| ) |  | const

Definition at line 451 of file paint.cc.

454 {
455 Vector2 blur_sigma(sigma.sigma, sigma.sigma);
456 if (!respect_ctm) {
457 blur_sigma /=
458 Vector2(ctm.GetBasisX().GetLength(), ctm.GetBasisY().GetLength());
459 }
460 if (is_solid_color) {
461 return FilterContents::MakeGaussianBlur(input, Sigma(blur_sigma.x),
462 Sigma(blur_sigma.y),
463 Entity::TileMode::kDecal, style);
464 }
465 return FilterContents::MakeBorderMaskBlur(input, Sigma(blur_sigma.x),
466 Sigma(blur_sigma.y), style);
467 }
impeller::Entity::TileMode::kDecal
@ kDecal
impeller::FilterContents::MakeBorderMaskBlur
static std::shared_ptr< FilterContents > MakeBorderMaskBlur(FilterInput::Ref input, Sigma sigma_x, Sigma sigma_y, BlurStyle blur_style=BlurStyle::kNormal)
Definition: filter_contents.cc:51
impeller::FilterContents::MakeGaussianBlur
static std::shared_ptr< FilterContents > MakeGaussianBlur(const FilterInput::Ref &input, Sigma sigma_x, Sigma sigma_y, Entity::TileMode tile_mode=Entity::TileMode::kDecal, BlurStyle mask_blur_style=BlurStyle::kNormal, const Geometry *mask_geometry=nullptr)
Definition: filter_contents.cc:38
impeller::Vector2
Point Vector2
Definition: point.h:331
impeller::Paint::MaskBlurDescriptor::respect_ctm
bool respect_ctm
Definition: paint.h:56
impeller::Paint::MaskBlurDescriptor::style
FilterContents::BlurStyle style
Definition: paint.h:52
impeller::Paint::MaskBlurDescriptor::sigma
Sigma sigma
Definition: paint.h:53
impeller::Sigma::sigma
Scalar sigma
Definition: sigma.h:33

References impeller::Matrix::GetBasisX(), impeller::Matrix::GetBasisY(), impeller::Vector3::GetLength(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

## ◆ CreateMaskBlur() [2/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur | ( | std::shared_ptr< ColorSourceContents > | color_source_contents,
|  | const flutter::DlColorFilter * | color_filter,
|  | bool | invert_colors,
|  | RectGeometry * | rect_geom
| ) |  | const

1. Create an opaque white mask of the original geometry.
2. Blur the mask.
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.
4. Apply the user set color filter on the GPU, if applicable.
5. Composite the color source with the blurred mask.

Definition at line 395 of file paint.cc.

399 {
400 // If it's a solid color then we can just get away with doing one Gaussian
401 // blur. The color filter will always be applied on the CPU.
402 if (color_source_contents->IsSolidColor()) {
403 return FilterContents::MakeGaussianBlur(
404 FilterInput::Make(color_source_contents), sigma, sigma,
405 Entity::TileMode::kDecal, style, color_source_contents->GetGeometry());
406 }
407
408 /// 1. Create an opaque white mask of the original geometry.
409
410 auto mask = std::make_shared<SolidColorContents>();
411 mask->SetColor(Color::White());
412 mask->SetGeometry(color_source_contents->GetGeometry());
413
414 /// 2. Blur the mask.
415
416 auto blurred_mask = FilterContents::MakeGaussianBlur(
417 FilterInput::Make(mask), sigma, sigma, Entity::TileMode::kDecal, style,
418 color_source_contents->GetGeometry());
419
420 /// 3. Replace the geometry of the original color source with a rectangle that
421 /// covers the full region of the blurred mask. Note that geometry is in
422 /// local bounds.
423
424 auto expanded_local_bounds = blurred_mask->GetCoverage({});
425 if (!expanded_local_bounds.has_value()) {
426 expanded_local_bounds = Rect();
427 }
428 *rect_geom = RectGeometry(expanded_local_bounds.value());
429 color_source_contents->SetGeometry(rect_geom);
430 std::shared_ptr<Contents> color_contents = color_source_contents;
431
432 /// 4. Apply the user set color filter on the GPU, if applicable.
433 if (color_filter) {
434 color_contents =
435 WrapWithGPUColorFilter(color_filter, FilterInput::Make(color_contents),
436 ColorFilterContents::AbsorbOpacity::kYes);
437 }
438 if (invert_colors) {
439 color_contents =
440 WrapWithInvertColors(FilterInput::Make(color_contents),
441 ColorFilterContents::AbsorbOpacity::kYes);
442 }
443
444 /// 5. Composite the color source with the blurred mask.
445
446 return ColorFilterContents::MakeBlend(
447 BlendMode::kSrcIn,
448 {FilterInput::Make(blurred_mask), FilterInput::Make(color_contents)});
449 }
impeller::ColorFilterContents::AbsorbOpacity::kYes
@ kYes
impeller::ColorFilterContents::MakeBlend
static std::shared_ptr< ColorFilterContents > MakeBlend(BlendMode blend_mode, FilterInput::Vector inputs, std::optional< Color > foreground_color=std::nullopt)
the [inputs] are expected to be in the order of dst, src.
Definition: color_filter_contents.cc:17
impeller::FilterInput::Make
static FilterInput::Ref Make(Variant input, bool msaa_enabled=true)
Definition: filter_input.cc:19
impeller::WrapWithGPUColorFilter
std::shared_ptr< ColorFilterContents > WrapWithGPUColorFilter(const flutter::DlColorFilter *filter, const std::shared_ptr< FilterInput > &input, ColorFilterContents::AbsorbOpacity absorb_opacity)
Definition: color_filter.cc:24
impeller::WrapWithInvertColors
std::shared_ptr< ColorFilterContents > WrapWithInvertColors(const std::shared_ptr< FilterInput > &input, ColorFilterContents::AbsorbOpacity absorb_opacity)
Definition: color_filter.cc:16
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:792
impeller::BlendMode::kSrcIn
@ kSrcIn
impeller::Color::White
static constexpr Color White()
Definition: color.h:264
impeller::Paint::color_filter
const flutter::DlColorFilter * color_filter
Definition: paint.h:76
impeller::Paint::invert_colors
bool invert_colors
Definition: paint.h:85

References impeller::WrapWithGPUColorFilter(), and impeller::WrapWithInvertColors().

## ◆ CreateMaskBlur() [3/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur | ( | std::shared_ptr< TextureContents > | texture_contents,
|  | RectGeometry * | rect_geom
| ) |  | const

Definition at line 365 of file paint.cc.

367 {
368 Scalar expand_amount = GaussianBlurFilterContents::CalculateBlurRadius(
369 GaussianBlurFilterContents::ScaleSigma(sigma.sigma));
370 texture_contents->SetSourceRect(
371 texture_contents->GetSourceRect().Expand(expand_amount, expand_amount));
372 auto mask = std::make_shared<SolidColorContents>();
373 mask->SetColor(Color::White());
374 std::optional<Rect> coverage = texture_contents->GetCoverage({});
375 Geometry* geometry = nullptr;
376 if (coverage) {
377 texture_contents->SetDestinationRect(
378 coverage.value().Expand(expand_amount, expand_amount));
379 *rect_geom = RectGeometry(coverage.value());
380 geometry = rect_geom;
381 }
382 mask->SetGeometry(geometry);
383 auto descriptor = texture_contents->GetSamplerDescriptor();
384 texture_contents->SetSamplerDescriptor(descriptor);
385 std::shared_ptr<FilterContents> blurred_mask =
386 FilterContents::MakeGaussianBlur(FilterInput::Make(mask), sigma, sigma,
387 Entity::TileMode::kDecal, style,
388 geometry);
389
390 return ColorFilterContents::MakeBlend(
391 BlendMode::kSrcIn,
392 {FilterInput::Make(blurred_mask), FilterInput::Make(texture_contents)});
393 }
impeller::GaussianBlurFilterContents::CalculateBlurRadius
static Scalar CalculateBlurRadius(Scalar sigma)
Definition: gaussian_blur_filter_contents.cc:882
impeller::GaussianBlurFilterContents::ScaleSigma
static Scalar ScaleSigma(Scalar sigma)
Definition: gaussian_blur_filter_contents.cc:902
impeller::Scalar
float Scalar
Definition: scalar.h:18

## Member Data Documentation

## ◆ respect_ctm

bool impeller::Paint::MaskBlurDescriptor::respect_ctm = true

Text mask blurs need to not apply the CTM to the blur kernel. See: https://github.com/flutter/flutter/issues/115112

Definition at line 56 of file paint.h.

## ◆ sigma

Sigma impeller::Paint::MaskBlurDescriptor::sigma

Definition at line 53 of file paint.h.

## ◆ style

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

Definition at line 52 of file paint.h.

Referenced by impeller::DlDispatcherBase::drawShadow().

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

- impeller/display_list/paint.h
- impeller/display_list/paint.cc