impeller::Paint::MaskBlurDescriptor Struct Reference

#include <paint.h>

Public Member Functions
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
std::shared_ptr< Contents >	CreateMaskBlur (const Paint &paint, const ContentContext &renderer, const Geometry *geometry, std::shared_ptr< ColorSourceContents > contents, bool needs_color_filter, FillRectGeometry *out_geom) const

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

Detailed Description

Definition at line 54 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 453 of file paint.cc.

                             {
  Vector2 blur_sigma(sigma.sigma, sigma.sigma);
  if (!respect_ctm) {
    blur_sigma /=
        Vector2(ctm.GetBasisX().GetLength(), ctm.GetBasisY().GetLength());
  }
  if (is_solid_color) {
    return FilterContents::MakeGaussianBlur(
        input, Sigma(blur_sigma.x), Sigma(blur_sigma.y),
        Entity::TileMode::kDecal, /*bounds=*/std::nullopt, style);
  }
  return FilterContents::MakeBorderMaskBlur(input, Sigma(blur_sigma.x),
                                            Sigma(blur_sigma.y), style);
}

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

CreateMaskBlur() [2/3]

std::shared_ptr< Contents > impeller::Paint::MaskBlurDescriptor::CreateMaskBlur	(	const Paint &	paint,
		const ContentContext &	renderer,
		const Geometry *	geometry,
		std::shared_ptr< ColorSourceContents >	contents,
		bool	needs_color_filter,
		FillRectGeometry *	out_geom
	)		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 396 of file paint.cc.

                                      {
  // If it's a solid color then we can just get  away with doing one Gaussian
  // blur. The color filter will always be applied on the CPU.
  if (contents->IsSolidColor()) {
    return FilterContents::MakeGaussianBlur(
        FilterInput::Make(contents), sigma, sigma, Entity::TileMode::kDecal,
        /*bounds=*/std::nullopt, style, geometry);
  }
 
  /// 1. Create an opaque white mask of the original geometry.
  auto mask = std::make_shared<SolidColorContents>(geometry);
  mask->SetColor(Color::White());
 
  /// 2. Blur the mask.
  auto blurred_mask = FilterContents::MakeGaussianBlur(
      FilterInput::Make(mask), sigma, sigma, Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, style, geometry);
 
  /// 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.
  std::optional<Rect> expanded_local_bounds = blurred_mask->GetCoverage({});
  if (!expanded_local_bounds.has_value()) {
    expanded_local_bounds = Rect();
  }
  *out_geom = FillRectGeometry(expanded_local_bounds.value());
 
  std::shared_ptr<ColorSourceContents> expanded_contents =
      paint.CreateContents(renderer, out_geom);
  std::shared_ptr<Contents> final_contents = expanded_contents;
 
  /// 4. Apply the user set color filter on the GPU, if applicable.
  if (needs_color_filter) {
    if (paint.color_filter) {
      final_contents = WrapWithGPUColorFilter(
          paint.color_filter, FilterInput::Make(std::move(final_contents)),
          ColorFilterContents::AbsorbOpacity::kYes);
    }
    if (paint.invert_colors) {
      final_contents =
          WrapWithInvertColors(FilterInput::Make(std::move(final_contents)),
                               ColorFilterContents::AbsorbOpacity::kYes);
    }
  }
 
  /// 5. Composite the color source with the blurred mask.
  return ColorFilterContents::MakeBlend(
      BlendMode::kSrcIn,
      {FilterInput::Make(blurred_mask), FilterInput::Make(final_contents)});
}

References impeller::Paint::color_filter, impeller::Paint::CreateContents(), impeller::Paint::invert_colors, 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 367 of file paint.cc.

                                       {
  Scalar expand_amount = GaussianBlurFilterContents::CalculateBlurRadius(
      GaussianBlurFilterContents::ScaleSigma(sigma.sigma));
  texture_contents->SetSourceRect(
      texture_contents->GetSourceRect().Expand(expand_amount, expand_amount));
  std::optional<Rect> coverage = texture_contents->GetCoverage({});
  Geometry* geometry = nullptr;
  if (coverage) {
    texture_contents->SetDestinationRect(
        coverage.value().Expand(expand_amount, expand_amount));
    *rect_geom = FillRectGeometry(coverage.value());
    geometry = rect_geom;
  }
  auto mask = std::make_shared<SolidColorContents>(geometry);
  mask->SetColor(Color::White());
  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,
          /*bounds=*/std::nullopt, style, geometry);
 
  return ColorFilterContents::MakeBlend(
      BlendMode::kSrcIn,
      {FilterInput::Make(blurred_mask), FilterInput::Make(texture_contents)});
}

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

sigma

Sigma impeller::Paint::MaskBlurDescriptor::sigma

Definition at line 56 of file paint.h.

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

style

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

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