flutter::OpacityLayer Class Reference

#include <opacity_layer.h>

Inheritance diagram for flutter::OpacityLayer:

Public Member Functions
	OpacityLayer (uint8_t alpha, const DlPoint &offset)
void	Diff (DiffContext *context, const Layer *old_layer) override
void	Preroll (PrerollContext *context) override
void	Paint (PaintContext &context) const override
bool	children_can_accept_opacity () const
void	set_children_can_accept_opacity (bool value)
DlScalar	opacity () const
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 17 of file opacity_layer.h.

Constructor & Destructor Documentation

OpacityLayer()

flutter::OpacityLayer::OpacityLayer	(	uint8_t	alpha,
		const DlPoint &	offset
	)

Definition at line 14 of file opacity_layer.cc.

    : CacheableContainerLayer(std::numeric_limits<int>::max(), true),
      alpha_(alpha),
      offset_(offset) {}

Member Function Documentation

children_can_accept_opacity()

bool flutter::OpacityLayer::children_can_accept_opacity ( ) const

inline

Definition at line 40 of file opacity_layer.h.

                                           {
    return children_can_accept_opacity_;
  }

Referenced by Paint(), and Preroll().

Diff()

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

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 19 of file opacity_layer.cc.

                                                                    {
  DiffContext::AutoSubtreeRestore subtree(context);
  auto* prev = static_cast<const OpacityLayer*>(old_layer);
  if (!context->IsSubtreeDirty()) {
    FML_DCHECK(prev);
    if (alpha_ != prev->alpha_ || offset_ != prev->offset_) {
      context->MarkSubtreeDirty(context->GetOldLayerPaintRegion(old_layer));
    }
  }
  context->PushTransform(DlMatrix::MakeTranslation(offset_));
  if (context->has_raster_cache()) {
    context->WillPaintWithIntegralTransform();
  }
  DiffChildren(context, prev);
  context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
}

References flutter::DiffContext::CurrentSubtreeRegion(), flutter::ContainerLayer::DiffChildren(), FML_DCHECK, flutter::DiffContext::GetOldLayerPaintRegion(), flutter::DiffContext::has_raster_cache(), flutter::DiffContext::IsSubtreeDirty(), impeller::Matrix::MakeTranslation(), flutter::DiffContext::MarkSubtreeDirty(), flutter::DiffContext::PushTransform(), flutter::DiffContext::SetLayerPaintRegion(), and flutter::DiffContext::WillPaintWithIntegralTransform().

opacity()

DlScalar flutter::OpacityLayer::opacity ( ) const

inline

Definition at line 47 of file opacity_layer.h.

{ return DlColor::toOpacity(alpha_); }

References flutter::DlColor::toOpacity().

Referenced by Paint(), and Preroll().

Paint()

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

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 71 of file opacity_layer.cc.

                                                    {
  FML_DCHECK(needs_painting(context));
 
  auto mutator = context.state_stack.save();
  mutator.translate(offset_.x, offset_.y);
 
#if !SLIMPELLER
  if (context.raster_cache) {
    mutator.integralTransform();
  }
#endif  //  !SLIMPELLER
 
  mutator.applyOpacity(child_paint_bounds(), opacity());
 
#if !SLIMPELLER
  if (!children_can_accept_opacity()) {
    DlPaint paint;
    if (layer_raster_cache_item_->Draw(context,
                                       context.state_stack.fill(paint))) {
      return;
    }
  }
#endif  //  !SLIMPELLER
 
  PaintChildren(context);
}

References flutter::ContainerLayer::child_paint_bounds(), children_can_accept_opacity(), flutter::LayerStateStack::fill(), FML_DCHECK, flutter::CacheableContainerLayer::layer_raster_cache_item_, flutter::Layer::needs_painting(), opacity(), flutter::ContainerLayer::PaintChildren(), flutter::LayerStateStack::save(), flutter::PaintContext::state_stack, flutter::LayerStateStack::MutatorContext::translate(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Preroll()

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

overridevirtual

Reimplemented from flutter::ContainerLayer.

Definition at line 36 of file opacity_layer.cc.

                                                  {
  auto mutator = context->state_stack.save();
  mutator.translate(offset_);
  mutator.applyOpacity(DlRect(), opacity());
 
#if !SLIMPELLER
  AutoCache auto_cache = AutoCache(layer_raster_cache_item_.get(), context,
                                   context->state_stack.matrix());
#endif  //  !SLIMPELLER
 
  Layer::AutoPrerollSaveLayerState save =
      Layer::AutoPrerollSaveLayerState::Create(context);
 
  ContainerLayer::Preroll(context);
  // We store the inheritance ability of our children for |Paint|
  set_children_can_accept_opacity((context->renderable_state_flags &
                                   LayerStateStack::kCallerCanApplyOpacity) !=
                                  0);
 
  // Now we let our parent layers know that we, too, can inherit opacity
  // regardless of what our children are capable of
  context->renderable_state_flags |= LayerStateStack::kCallerCanApplyOpacity;
 
  set_paint_bounds(paint_bounds().Shift(offset_));
 
#if !SLIMPELLER
  if (children_can_accept_opacity()) {
    // For opacity layer, we can use raster_cache children only when the
    // children can't accept opacity so if the children_can_accept_opacity we
    // should tell the AutoCache object don't do raster_cache.
    auto_cache.ShouldNotBeCached();
  }
#endif  //  !SLIMPELLER
}

References children_can_accept_opacity(), flutter::Layer::AutoPrerollSaveLayerState::Create(), flutter::LayerStateStack::kCallerCanApplyOpacity, flutter::CacheableContainerLayer::layer_raster_cache_item_, flutter::LayerStateStack::matrix(), opacity(), flutter::Layer::paint_bounds(), flutter::ContainerLayer::Preroll(), flutter::PrerollContext::renderable_state_flags, flutter::LayerStateStack::save(), set_children_can_accept_opacity(), flutter::Layer::set_paint_bounds(), flutter::AutoCache::ShouldNotBeCached(), flutter::PrerollContext::state_stack, and flutter::LayerStateStack::MutatorContext::translate().

set_children_can_accept_opacity()

void flutter::OpacityLayer::set_children_can_accept_opacity ( bool  value )

inline

Definition at line 43 of file opacity_layer.h.

                                                   {
    children_can_accept_opacity_ = value;
  }

References value.

Referenced by Preroll().

---

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

• flow/layers/opacity_layer.h
• flow/layers/opacity_layer.cc