flutter::ImageFilterLayer Class Reference

#include <image_filter_layer.h>

Inheritance diagram for flutter::ImageFilterLayer:

Public Member Functions
	ImageFilterLayer (const std::shared_ptr< DlImageFilter > &filter, const DlPoint &offset=DlPoint())
void	Diff (DiffContext *context, const Layer *old_layer) override
void	Preroll (PrerollContext *context) override
void	Paint (PaintContext &context) const override
Public Member Functions inherited from flutter::CacheableContainerLayer
	CacheableContainerLayer (int layer_cached_threshold=RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer, bool can_cache_children=false)
const LayerRasterCacheItem *	raster_cache_item () const
Public Member Functions inherited from flutter::ContainerLayer
	ContainerLayer ()
void	PreservePaintRegion (DiffContext *context) override
virtual void	Add (std::shared_ptr< Layer > layer)
const std::vector< std::shared_ptr< Layer > > &	layers () const
virtual void	DiffChildren (DiffContext *context, const ContainerLayer *old_layer)
void	PaintChildren (PaintContext &context) const override
const ContainerLayer *	as_container_layer () const override
const DlRect &	child_paint_bounds () const
void	set_child_paint_bounds (const DlRect &bounds)
int	children_renderable_state_flags () const
void	set_children_renderable_state_flags (int flags)
Public Member Functions inherited from flutter::Layer
	Layer ()
virtual	~Layer ()
void	AssignOldLayer (Layer *old_layer)
virtual bool	IsReplacing (DiffContext *context, const Layer *old_layer) const
bool	subtree_has_platform_view () const
void	set_subtree_has_platform_view (bool value)
const DlRect &	paint_bounds () const
void	set_paint_bounds (const DlRect &paint_bounds)
bool	is_empty () const
bool	needs_painting (PaintContext &context) const
uint64_t	original_layer_id () const
uint64_t	unique_id () const
virtual RasterCacheKeyID	caching_key_id () const
virtual const DisplayListLayer *	as_display_list_layer () const
virtual const TextureLayer *	as_texture_layer () const
virtual const PerformanceOverlayLayer *	as_performance_overlay_layer () const
virtual const testing::MockLayer *	as_mock_layer () const

Additional Inherited Members
Static Public Attributes inherited from flutter::Layer
static constexpr int	kSaveLayerRenderFlags
static constexpr int	kRasterCacheRenderFlags
Protected Member Functions inherited from flutter::ContainerLayer
void	PrerollChildren (PrerollContext *context, DlRect *child_paint_bounds)
Protected Attributes inherited from flutter::CacheableContainerLayer
std::unique_ptr< LayerRasterCacheItem >	layer_raster_cache_item_

Detailed Description

Definition at line 13 of file image_filter_layer.h.

Constructor & Destructor Documentation

ImageFilterLayer()

flutter::ImageFilterLayer::ImageFilterLayer ( const std::shared_ptr< DlImageFilter > &  filter, const DlPoint &  offset = DlPoint()  )

explicit

Definition at line 13 of file image_filter_layer.cc.

    : CacheableContainerLayer(
          RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer),
      offset_(offset),
      filter_(filter),
      transformed_filter_(nullptr) {}

Member Function Documentation

Diff()

void flutter::ImageFilterLayer::Diff ( DiffContext *  context, const Layer *  old_layer  )

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 21 of file image_filter_layer.cc.

                                                                        {
  DiffContext::AutoSubtreeRestore subtree(context);
  auto* prev = static_cast<const ImageFilterLayer*>(old_layer);
  if (!context->IsSubtreeDirty()) {
    FML_DCHECK(prev);
    if (NotEquals(filter_, prev->filter_) || offset_ != prev->offset_) {
      context->MarkSubtreeDirty(context->GetOldLayerPaintRegion(old_layer));
    }
  }
 
  context->PushTransform(DlMatrix::MakeTranslation(offset_));
  if (context->has_raster_cache()) {
    context->WillPaintWithIntegralTransform();
  }
 
  if (filter_) {
    auto filter = filter_->makeWithLocalMatrix(context->GetMatrix());
    if (filter) {
      // This transform will be applied to every child rect in the subtree
      context->PushFilterBoundsAdjustment([filter](DlRect rect) {
        DlIRect filter_out_bounds;
        filter->map_device_bounds(DlIRect::RoundOut(rect), DlMatrix(),
                                  filter_out_bounds);
        return DlRect::Make(filter_out_bounds);
      });
    }
  }
  DiffChildren(context, prev);
  context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
}

References context, flutter::ContainerLayer::DiffChildren(), FML_DCHECK, impeller::TRect< Scalar >::Make(), impeller::Matrix::MakeTranslation(), flutter::NotEquals(), and impeller::TRect< T >::RoundOut().

Paint()

void flutter::ImageFilterLayer::Paint ( PaintContext &  context ) const

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 104 of file image_filter_layer.cc.

                                                        {
  FML_DCHECK(needs_painting(context));
 
  auto mutator = context.state_stack.save();
 
#if !SLIMPELLER
  if (context.raster_cache) {
    // Try drawing the layer cache item from the cache before applying the
    // image filter if it was cached with the filter applied.
    if (!layer_raster_cache_item_->IsCacheChildren()) {
      DlPaint paint;
      if (layer_raster_cache_item_->Draw(context,
                                         context.state_stack.fill(paint))) {
        return;
      }
    }
  }
#endif  //  !SLIMPELLER
 
  // Only apply the offset if not being raster-cached to avoid the offset being
  // applied twice.
  mutator.translate(offset_);
 
#if !SLIMPELLER
  if (context.raster_cache) {
    mutator.integralTransform();
  }
 
  if (context.raster_cache && layer_raster_cache_item_->IsCacheChildren()) {
    // If we render the children from cache then we need the special
    // transformed version of the filter so we must process it into the
    // cache paint object manually.
    FML_DCHECK(transformed_filter_ != nullptr);
    DlPaint paint;
    context.state_stack.fill(paint);
    paint.setImageFilter(transformed_filter_);
    if (layer_raster_cache_item_->Draw(context, &paint)) {
      return;
    }
  }
#endif  //  !SLIMPELLER
 
  // Now apply the image filter and then try rendering the children.
  mutator.applyImageFilter(child_paint_bounds(), filter_);
 
  PaintChildren(context);
}

References flutter::ContainerLayer::child_paint_bounds(), context, FML_DCHECK, flutter::CacheableContainerLayer::layer_raster_cache_item_, flutter::Layer::needs_painting(), flutter::ContainerLayer::PaintChildren(), and flutter::DlPaint::setImageFilter().

Preroll()

void flutter::ImageFilterLayer::Preroll ( PrerollContext *  context )

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 52 of file image_filter_layer.cc.

                                                      {
  auto mutator = context->state_stack.save();
  mutator.translate(offset_);
 
  Layer::AutoPrerollSaveLayerState save =
      Layer::AutoPrerollSaveLayerState::Create(context);
 
#if !SLIMPELLER
  AutoCache cache = AutoCache(layer_raster_cache_item_.get(), context,
                              context->state_stack.matrix());
#endif  //  !SLIMPELLER
 
  DlRect child_bounds;
 
  PrerollChildren(context, &child_bounds);
 
  if (!filter_) {
    child_bounds = child_bounds.Shift(offset_);
    set_paint_bounds(child_bounds);
    return;
  }
 
  // Our saveLayer would apply any outstanding opacity or any outstanding
  // color filter after it applies our image filter. So we can apply either
  // of those attributes with our saveLayer.
  context->renderable_state_flags =
      (LayerStateStack::kCallerCanApplyOpacity |
       LayerStateStack::kCallerCanApplyColorFilter);
 
  const DlIRect filter_in_bounds = DlIRect::RoundOut(child_bounds);
  DlIRect filter_out_bounds;
  filter_->map_device_bounds(filter_in_bounds, DlMatrix(), filter_out_bounds);
  child_bounds = DlRect::Make(filter_out_bounds).Shift(offset_);
 
  set_paint_bounds(child_bounds);
 
#if !SLIMPELLER
  // CacheChildren only when the transformed_filter_ doesn't equal null.
  // So in here we reset the LayerRasterCacheItem cache state.
  layer_raster_cache_item_->MarkNotCacheChildren();
#endif  //  !SLIMPELLER
 
  transformed_filter_ =
      filter_->makeWithLocalMatrix(context->state_stack.matrix());
 
#if !SLIMPELLER
  if (transformed_filter_) {
    layer_raster_cache_item_->MarkCacheChildren();
  }
#endif  //  !SLIMPELLER
}

References context, flutter::Layer::AutoPrerollSaveLayerState::Create(), flutter::LayerStateStack::kCallerCanApplyColorFilter, flutter::LayerStateStack::kCallerCanApplyOpacity, flutter::CacheableContainerLayer::layer_raster_cache_item_, impeller::TRect< Scalar >::Make(), flutter::ContainerLayer::PrerollChildren(), impeller::TRect< T >::RoundOut(), flutter::Layer::set_paint_bounds(), and impeller::TRect< T >::Shift().

---

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

• flow/layers/image_filter_layer.h
• flow/layers/image_filter_layer.cc