sksg::MaskEffect Class Reference

#include <SkSGMaskEffect.h>

Inheritance diagram for sksg::MaskEffect:

Public Types
enum class	Mode : uint32_t { kAlphaNormal , kAlphaInvert , kLumaNormal , kLumaInvert }

Public Member Functions
	~MaskEffect () override
Public Member Functions inherited from sksg::RenderNode
void	render (SkCanvas *, const RenderContext *=nullptr) const
const RenderNode *	nodeAt (const SkPoint &point) const
bool	isVisible () const
void	setVisible (bool)
Public Member Functions inherited from sksg::Node
const SkRect &	revalidate (InvalidationController *, const SkMatrix &)
void	invalidate (bool damage=true)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< MaskEffect >	Make (sk_sp< RenderNode > child, sk_sp< RenderNode > mask, Mode mode=Mode::kAlphaNormal)

Protected Member Functions
	MaskEffect (sk_sp< RenderNode >, sk_sp< RenderNode > mask, Mode)
void	onRender (SkCanvas *, const RenderContext *) const override
const RenderNode *	onNodeAt (const SkPoint &) const override
SkRect	onRevalidate (InvalidationController *, const SkMatrix &) override
Protected Member Functions inherited from sksg::EffectNode
	EffectNode (sk_sp< RenderNode >, uint32_t inval_traits=0)
	~EffectNode () override
void	onRender (SkCanvas *, const RenderContext *) const override
const RenderNode *	onNodeAt (const SkPoint &) const override
SkRect	onRevalidate (InvalidationController *, const SkMatrix &) override
const sk_sp< RenderNode > &	getChild () const
Protected Member Functions inherited from sksg::RenderNode
	RenderNode (uint32_t inval_traits=0)
virtual void	onRender (SkCanvas *, const RenderContext *) const =0
virtual const RenderNode *	onNodeAt (const SkPoint &p) const =0
Protected Member Functions inherited from sksg::Node
	Node (uint32_t invalTraits)
	~Node () override
const SkRect &	bounds () const
bool	hasInval () const
virtual SkRect	onRevalidate (InvalidationController *, const SkMatrix &ctm)=0
void	observeInval (const sk_sp< Node > &)
void	unobserveInval (const sk_sp< Node > &)

Additional Inherited Members
Protected Types inherited from sksg::Node
enum	InvalTraits { kBubbleDamage_Trait = 1 << 0 , kOverrideDamage_Trait = 1 << 1 }

Detailed Description

Concrete Effect node, applying a mask to its descendants.

Definition at line 30 of file SkSGMaskEffect.h.

Member Enumeration Documentation

Mode

enum class sksg::MaskEffect::Mode : uint32_t

strong

Enumerator
kAlphaNormal
kAlphaInvert
kLumaNormal
kLumaInvert

Definition at line 32 of file SkSGMaskEffect.h.

                    : uint32_t {
        kAlphaNormal,
        kAlphaInvert,
        kLumaNormal,
        kLumaInvert,
    };

Constructor & Destructor Documentation

~MaskEffect()

sksg::MaskEffect::~MaskEffect ( )

override

Definition at line 39 of file SkSGMaskEffect.cpp.

                        {
    this->unobserveInval(fMaskNode);
}

MaskEffect()

sksg::MaskEffect::MaskEffect ( sk_sp< RenderNode >  child, sk_sp< RenderNode >  mask, Mode  mode  )

protected

Definition at line 32 of file SkSGMaskEffect.cpp.

    : INHERITED(std::move(child))
    , fMaskNode(std::move(mask))
    , fMaskMode(mode) {
    this->observeInval(fMaskNode);
}

Member Function Documentation

Make()

static sk_sp< MaskEffect > sksg::MaskEffect::Make ( sk_sp< RenderNode >  child, sk_sp< RenderNode >  mask, Mode  mode = Mode::kAlphaNormal  )

inlinestatic

Definition at line 39 of file SkSGMaskEffect.h.

                                                                {
        return (child && mask)
            ? sk_sp<MaskEffect>(new MaskEffect(std::move(child), std::move(mask), mode))
            : nullptr;
    }

onNodeAt()

const RenderNode * sksg::MaskEffect::onNodeAt ( const SkPoint &  p ) const

overrideprotectedvirtual

Reimplemented from sksg::EffectNode.

Definition at line 85 of file SkSGMaskEffect.cpp.

                                                             {
    const auto mask_hit = (SkToBool(fMaskNode->nodeAt(p)) == !is_inverted(fMaskMode));
 
    if (!mask_hit) {
        return nullptr;
    }
 
    return this->INHERITED::onNodeAt(p);
}

onRender()

void sksg::MaskEffect::onRender ( SkCanvas *  canvas, const RenderContext *  ctx  ) const

overrideprotectedvirtual

Reimplemented from sksg::EffectNode.

Definition at line 43 of file SkSGMaskEffect.cpp.

                                                                          {
    SkAutoCanvasRestore acr(canvas, false);
 
    // The mask mode covers two independent bits.
    //
    //   - mask source controls how the mask coverage is generated:
    //     * alpha => coverage = mask_alpha
    //     * luma  => coverage = luma(mask_rgb)
    //
    //   - mask type controls how the mask coverage is interpreted:
    //     * normal   => coverage' = coverage
    //     * inverted => coverage' = 1 - coverage
 
    {
        // Outer layer: mask coverage stored in the alpha channel.
        SkPaint mask_layer_paint;
        if (ctx) {
            // Apply all optional context overrides upfront.
            ctx->modulatePaint(canvas->getTotalMatrix(), &mask_layer_paint);
        }
 
        RenderContext mask_render_context;
        if (is_luma(fMaskMode)) {
            mask_render_context.fColorFilter = SkLumaColorFilter::Make();
        }
 
        // TODO: could be an A8 layer?
        canvas->saveLayer(this->bounds(), &mask_layer_paint);
        fMaskNode->render(canvas, &mask_render_context);
 
        {
            // Inner layer: masked content.
            SkPaint content_layer_paint;
            content_layer_paint.setBlendMode(is_inverted(fMaskMode) ? SkBlendMode::kSrcOut
                                                                    : SkBlendMode::kSrcIn);
            canvas->saveLayer(this->bounds(), &content_layer_paint);
 
            this->INHERITED::onRender(canvas, nullptr);
        }
    }
}

onRevalidate()

SkRect sksg::MaskEffect::onRevalidate ( InvalidationController *  ic, const SkMatrix &  ctm  )

overrideprotectedvirtual

Reimplemented from sksg::EffectNode.

Definition at line 95 of file SkSGMaskEffect.cpp.

                                                                               {
    SkASSERT(this->hasInval());
 
    const auto maskBounds = fMaskNode->revalidate(ic, ctm);
    auto childBounds = this->INHERITED::onRevalidate(ic, ctm);
 
    return (is_inverted(fMaskMode) || childBounds.intersect(maskBounds))
        ? childBounds
        : SkRect::MakeEmpty();
}

---

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

• third_party/skia/modules/sksg/include/SkSGMaskEffect.h
• third_party/skia/modules/sksg/src/SkSGMaskEffect.cpp