| 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, FillRectGeometry *rect_geom) const
std::shared_ptr< FilterContents > | CreateMaskBlur (std::shared_ptr< TextureContents > texture_contents, FillRectGeometry *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 52 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 452 of file paint.cc.

455 {
456 Vector2 blur_sigma(sigma.sigma, sigma.sigma);
457 if (!respect_ctm) {
458 blur_sigma /=
459 Vector2(ctm.GetBasisX().GetLength(), ctm.GetBasisY().GetLength());
460 }
461 if (is_solid_color) {
462 return FilterContents::MakeGaussianBlur(
463 input, Sigma(blur_sigma.x), Sigma(blur_sigma.y),
464 Entity::TileMode::kDecal, /*bounds=*/std::nullopt, style);
465 }
466 return FilterContents::MakeBorderMaskBlur(input, Sigma(blur_sigma.x),
467 Sigma(blur_sigma.y), style);
468 }
impeller::Entity::TileMode::kDecal
@ kDecal
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, std::optional< Rect > bounds=std::nullopt, BlurStyle mask_blur_style=BlurStyle::kNormal, const Geometry *mask_geometry=nullptr)
Definition: filter_contents.cc:37
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:52
impeller::Vector2
Point Vector2
Definition: point.h:429
impeller::Paint::MaskBlurDescriptor::respect_ctm
bool respect_ctm
Definition: paint.h:57
impeller::Paint::MaskBlurDescriptor::style
FilterContents::BlurStyle style
Definition: paint.h:53
impeller::Paint::MaskBlurDescriptor::sigma
Sigma sigma
Definition: paint.h:54
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,
|  | FillRectGeometry * | 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, /*bounds=*/std::nullopt, style,
406 color_source_contents->GetGeometry());
407 }
408
409 /// 1. Create an opaque white mask of the original geometry.
410
411 auto mask = std::make_shared<SolidColorContents>();
412 mask->SetColor(Color::White());
413 mask->SetGeometry(color_source_contents->GetGeometry());
414
415 /// 2. Blur the mask.
416
417 auto blurred_mask = FilterContents::MakeGaussianBlur(
418 FilterInput::Make(mask), sigma, sigma, Entity::TileMode::kDecal,
419 /*bounds=*/std::nullopt, style, color_source_contents->GetGeometry());
420
421 /// 3. Replace the geometry of the original color source with a rectangle that
422 /// covers the full region of the blurred mask. Note that geometry is in
423 /// local bounds.
424
425 auto expanded_local_bounds = blurred_mask->GetCoverage({});
426 if (!expanded_local_bounds.has_value()) {
427 expanded_local_bounds = Rect();
428 }
429 *rect_geom = FillRectGeometry(expanded_local_bounds.value());
430 color_source_contents->SetGeometry(rect_geom);
431 std::shared_ptr<Contents> color_contents = color_source_contents;
432
433 /// 4. Apply the user set color filter on the GPU, if applicable.
434 if (color_filter) {
435 color_contents =
436 WrapWithGPUColorFilter(color_filter, FilterInput::Make(color_contents),
437 ColorFilterContents::AbsorbOpacity::kYes);
438 }
439 if (invert_colors) {
440 color_contents =
441 WrapWithInvertColors(FilterInput::Make(color_contents),
442 ColorFilterContents::AbsorbOpacity::kYes);
443 }
444
445 /// 5. Composite the color source with the blurred mask.
446
447 return ColorFilterContents::MakeBlend(
448 BlendMode::kSrcIn,
449 {FilterInput::Make(blurred_mask), FilterInput::Make(color_contents)});
450 }
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:788
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:77
impeller::Paint::invert_colors
bool invert_colors
Definition: paint.h:83

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

## ◆ CreateMaskBlur() [3/3]

std::shared_ptr< FilterContents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur | ( | std::shared_ptr< TextureContents > | texture_contents,
|  | FillRectGeometry * | 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 = FillRectGeometry(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(
387 FilterInput::Make(mask), sigma, sigma, Entity::TileMode::kDecal,
388 /*bounds=*/std::nullopt, style, 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:1019
impeller::GaussianBlurFilterContents::ScaleSigma
static Scalar ScaleSigma(Scalar sigma)
Definition: gaussian_blur_filter_contents.cc:1039
impeller::Scalar
float Scalar
Definition: scalar.h:19

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

## ◆ sigma

Sigma impeller::Paint::MaskBlurDescriptor::sigma

Definition at line 54 of file paint.h.

Referenced by impeller::testing::TEST_P().

## ◆ style

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

Definition at line 53 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