#include <morphology_filter_contents.h>

Inheritance diagram for impeller::DirectionalMorphologyFilterContents:

Public Member Functions
	DirectionalMorphologyFilterContents ()

	~DirectionalMorphologyFilterContents () override

void	SetRadius (Radius radius)

void	SetDirection (Vector2 direction)

void	SetMorphType (MorphType morph_type)

std::optional< Rect >	GetFilterCoverage (const FilterInput::Vector &inputs, const Entity &entity, const Matrix &effect_transform) const override
	Internal utility method for \|GetLocalCoverage\| that computes the output coverage of this filter across the specified inputs, ignoring the coverage hint. More...

std::optional< Rect >	GetFilterSourceCoverage (const Matrix &effect_transform, const Rect &output_limit) const override
	Internal utility method for \|GetSourceCoverage\| that computes the inverse effect of this transform on the specified output coverage, ignoring the inputs which will be accommodated by the caller. More...

Public Member Functions inherited from impeller::FilterContents
	FilterContents ()

	~FilterContents () override

void	SetInputs (FilterInput::Vector inputs)
	The input texture sources for this filter. Each input's emitted texture is expected to have premultiplied alpha colors. More...

void	SetEffectTransform (const Matrix &effect_transform)
	Sets the transform which gets appended to the effect of this filter. Note that this is in addition to the entity's transform. More...

std::optional< Entity >	GetEntity (const ContentContext &renderer, const Entity &entity, const std::optional< Rect > &coverage_hint) const
	Create an Entity that renders this filter's output. More...

bool	Render (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override

std::optional< Rect >	GetCoverage (const Entity &entity) const override
	Get the area of the render pass that will be affected when this contents is rendered. More...

std::optional< Snapshot >	RenderToSnapshot (const ContentContext &renderer, const Entity &entity, std::optional< Rect > coverage_limit=std::nullopt, const std::optional< SamplerDescriptor > &sampler_descriptor=std::nullopt, bool msaa_enabled=true, int32_t mip_count=1, std::string_view label="Filter Snapshot") const override
	Render this contents to a snapshot, respecting the entity's transform, path, clip depth, and blend mode. The result texture size is always the size of `GetCoverage(entity)`. More...

std::optional< Rect >	GetSourceCoverage (const Matrix &effect_transform, const Rect &output_limit) const
	Determines the coverage of source pixels that will be needed to produce results for the specified \|output_limit\| under the specified \|effect_transform\|. This is essentially a reverse of the \|GetCoverage\| method computing a source coverage from an intended \|output_limit\| coverage. More...

virtual Matrix	GetLocalTransform (const Matrix &parent_transform) const

Matrix	GetTransform (const Matrix &parent_transform) const

virtual void	SetRenderingMode (Entity::RenderingMode rendering_mode)
	Marks this filter chain as applying in a subpass scenario. More...

Public Member Functions inherited from impeller::Contents
	Contents ()

virtual	~Contents ()

void	SetCoverageHint (std::optional< Rect > coverage_hint)
	Hint that specifies the coverage area of this Contents that will actually be used during rendering. This is for optimization purposes only and can not be relied on as a clip. May optionally affect the result of `GetCoverage()`. More...

const std::optional< Rect > &	GetCoverageHint () const

virtual bool	IsOpaque (const Matrix &transform) const
	Whether this Contents only emits opaque source colors from the fragment stage. This value does not account for any entity properties (e.g. the blend mode), clips/visibility culling, or inherited opacity. More...

std::optional< Size >	GetColorSourceSize () const
	Return the color source's intrinsic size, if available. More...

void	SetColorSourceSize (Size size)

virtual void	SetInheritedOpacity (Scalar opacity)
	Inherit the provided opacity. More...

virtual std::optional< Color >	AsBackgroundColor (const Entity &entity, ISize target_size) const
	Returns a color if this Contents will flood the given `target_size` with a color. This output color is the "Source" color that will be used for the Entity's blend operation. More...

virtual bool	ApplyColorFilter (const ColorFilterProc &color_filter_proc)
	If possible, applies a color filter to this contents inputs on the CPU. More...

Additional Inherited Members
Public Types inherited from impeller::FilterContents
enum class	BlurStyle { kNormal , kSolid , kOuter , kInner }

enum class	MorphType { kDilate , kErode }

Public Types inherited from impeller::Contents
using	ColorFilterProc = std::function< Color(Color)>

using	RenderProc = std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)>

using	CoverageProc = std::function< std::optional< Rect >(const Entity &entity)>

Static Public Member Functions inherited from impeller::FilterContents
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)

static std::shared_ptr< FilterContents >	MakeBorderMaskBlur (FilterInput::Ref input, Sigma sigma_x, Sigma sigma_y, BlurStyle blur_style=BlurStyle::kNormal)

static std::shared_ptr< FilterContents >	MakeDirectionalMorphology (FilterInput::Ref input, Radius radius, Vector2 direction, MorphType morph_type)

static std::shared_ptr< FilterContents >	MakeMorphology (FilterInput::Ref input, Radius radius_x, Radius radius_y, MorphType morph_type)

static std::shared_ptr< FilterContents >	MakeMatrixFilter (FilterInput::Ref input, const Matrix &matrix, const SamplerDescriptor &desc)

static std::shared_ptr< FilterContents >	MakeLocalMatrixFilter (FilterInput::Ref input, const Matrix &matrix)

static std::shared_ptr< FilterContents >	MakeYUVToRGBFilter (std::shared_ptr< Texture > y_texture, std::shared_ptr< Texture > uv_texture, YUVColorSpace yuv_color_space)

static std::shared_ptr< FilterContents >	MakeRuntimeEffect (FilterInput::Ref input, std::shared_ptr< RuntimeStage > runtime_stage, std::shared_ptr< std::vector< uint8_t >> uniforms, std::vector< RuntimeEffectContents::TextureInput > texture_inputs)

Static Public Member Functions inherited from impeller::Contents
static std::shared_ptr< Contents >	MakeAnonymous (RenderProc render_proc, CoverageProc coverage_proc)

Static Public Attributes inherited from impeller::FilterContents
static const int32_t	kBlurFilterRequiredMipCount

Detailed Description

Definition at line 15 of file morphology_filter_contents.h.

Constructor & Destructor Documentation

◆ DirectionalMorphologyFilterContents()

impeller::DirectionalMorphologyFilterContents::DirectionalMorphologyFilterContents ( )

default

◆ ~DirectionalMorphologyFilterContents()

impeller::DirectionalMorphologyFilterContents::~DirectionalMorphologyFilterContents ( )

overridedefault

Member Function Documentation

◆ GetFilterCoverage()

std::optional< Rect > impeller::DirectionalMorphologyFilterContents::GetFilterCoverage	(	const FilterInput::Vector &	inputs,
		const Entity &	entity,
		const Matrix &	effect_transform
	)		const

overridevirtual

Internal utility method for |GetLocalCoverage| that computes the output coverage of this filter across the specified inputs, ignoring the coverage hint.

Reimplemented from impeller::FilterContents.

Definition at line 169 of file morphology_filter_contents.cc.

                                           {
   if (inputs.empty()) {
     return std::nullopt;
   }
  
   auto coverage = inputs[0]->GetCoverage(entity);
   if (!coverage.has_value()) {
     return std::nullopt;
   }
   auto transform = inputs[0]->GetTransform(entity) * effect_transform.Basis();
   auto transformed_vector =
       transform.TransformDirection(direction_ * radius_.radius).Abs();
  
   auto origin = coverage->GetOrigin();
   auto size = Vector2(coverage->GetSize());
   switch (morph_type_) {
     case FilterContents::MorphType::kDilate:
       origin -= transformed_vector;
       size += transformed_vector * 2;
       break;
     case FilterContents::MorphType::kErode:
       origin += transformed_vector;
       size -= transformed_vector * 2;
       break;
   }
   if (size.x < 0 || size.y < 0) {
     return Rect::MakeSize(Size(0, 0));
   }
   return Rect::MakeOriginSize(origin, Size(size.x, size.y));
 }

References impeller::Matrix::Basis(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::FilterContents::kDilate, impeller::FilterContents::kErode, impeller::TRect< Scalar >::MakeOriginSize(), impeller::TRect< Scalar >::MakeSize(), impeller::Radius::radius, and transform.

◆ GetFilterSourceCoverage()

std::optional< Rect > impeller::DirectionalMorphologyFilterContents::GetFilterSourceCoverage	(	const Matrix &	effect_transform,
		const Rect &	output_limit
	)		const

overridevirtual

Internal utility method for |GetSourceCoverage| that computes the inverse effect of this transform on the specified output coverage, ignoring the inputs which will be accommodated by the caller.

Implements impeller::FilterContents.

Definition at line 204 of file morphology_filter_contents.cc.

                                     {
   auto transformed_vector =
       effect_transform.TransformDirection(direction_ * radius_.radius).Abs();
   switch (morph_type_) {
     case FilterContents::MorphType::kDilate:
       return output_limit.Expand(-transformed_vector);
     case FilterContents::MorphType::kErode:
       return output_limit.Expand(transformed_vector);
   }
 }

References impeller::TRect< T >::Expand(), impeller::FilterContents::kDilate, impeller::FilterContents::kErode, impeller::Radius::radius, and impeller::Matrix::TransformDirection().

◆ SetDirection()

void impeller::DirectionalMorphologyFilterContents::SetDirection ( Vector2 direction )

Definition at line 27 of file morphology_filter_contents.cc.

                                                                         {
   direction_ = direction.Normalize();
   if (direction_.IsZero()) {
     direction_ = Vector2(0, 1);
   }
 }

References impeller::TPoint< T >::IsZero(), and impeller::TPoint< T >::Normalize().

◆ SetMorphType()

void impeller::DirectionalMorphologyFilterContents::SetMorphType ( MorphType morph_type )

Definition at line 34 of file morphology_filter_contents.cc.

                                                                            {
   morph_type_ = morph_type;
 }

◆ SetRadius()

void impeller::DirectionalMorphologyFilterContents::SetRadius ( Radius radius )

Definition at line 23 of file morphology_filter_contents.cc.

                                                                  {
   radius_ = radius;
 }

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

impeller/entity/contents/filters/morphology_filter_contents.h
impeller/entity/contents/filters/morphology_filter_contents.cc

Public Member Functions

Additional Inherited Members