sksg::RenderNode::ScopedRenderContext Class Reference

#include <SkSGRenderNode.h>

Public Member Functions
	ScopedRenderContext (SkCanvas *, const RenderContext *)
	~ScopedRenderContext ()
	ScopedRenderContext (ScopedRenderContext &&that)
ScopedRenderContext &	operator= (ScopedRenderContext &&that)
	operator const RenderContext * () const
const RenderContext *	operator-> () const
ScopedRenderContext &&	modulateOpacity (float opacity)
ScopedRenderContext &&	modulateColorFilter (sk_sp< SkColorFilter >)
ScopedRenderContext &&	modulateShader (sk_sp< SkShader >, const SkMatrix &shader_ctm)
ScopedRenderContext &&	modulateMaskShader (sk_sp< SkShader >, const SkMatrix &ms_ctm)
ScopedRenderContext &&	modulateBlender (sk_sp< SkBlender >)
ScopedRenderContext &&	setIsolation (const SkRect &bounds, const SkMatrix &ctm, bool do_isolate)
ScopedRenderContext &&	setFilterIsolation (const SkRect &bounds, const SkMatrix &ctm, sk_sp< SkImageFilter >)

Detailed Description

Definition at line 75 of file SkSGRenderNode.h.

Constructor & Destructor Documentation

ScopedRenderContext() [1/2]

sksg::RenderNode::ScopedRenderContext::ScopedRenderContext	(	SkCanvas *	canvas,
		const RenderContext *	ctx
	)

Definition at line 122 of file SkSGRenderNode.cpp.

    : fCanvas(canvas)
    , fCtx(ctx ? *ctx : RenderContext())
    , fRestoreCount(canvas->getSaveCount()) {}

~ScopedRenderContext()

sksg::RenderNode::ScopedRenderContext::~ScopedRenderContext

(

)

Definition at line 127 of file SkSGRenderNode.cpp.

                                                    {
    if (fRestoreCount >= 0) {
        if (fMaskShader) {
            SkPaint mask_paint;
            mask_paint.setBlendMode(SkBlendMode::kDstIn);
            mask_paint.setShader(std::move(fMaskShader));
            fCanvas->drawPaint(mask_paint);
        }
        fCanvas->restoreToCount(fRestoreCount);
    }
}

ScopedRenderContext() [2/2]

sksg::RenderNode::ScopedRenderContext::ScopedRenderContext ( ScopedRenderContext &&  that )

inline

Definition at line 80 of file SkSGRenderNode.h.

{ *this = std::move(that); }

Member Function Documentation

modulateBlender()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::modulateBlender

(

sk_sp< SkBlender >

blender

)

Definition at line 188 of file SkSGRenderNode.cpp.

                                                                       {
    fCtx.fBlender = std::move(blender);
    return std::move(*this);
}

modulateColorFilter()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::modulateColorFilter

(

sk_sp< SkColorFilter >

cf

)

Definition at line 147 of file SkSGRenderNode.cpp.

                                                                          {
    fCtx.fColorFilter = SkColorFilters::Compose(std::move(fCtx.fColorFilter), std::move(cf));
    return std::move(*this);
}

modulateMaskShader()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::modulateMaskShader	(	sk_sp< SkShader >	ms,
		const SkMatrix &	ms_ctm
	)

Definition at line 164 of file SkSGRenderNode.cpp.

                                                                                         {
    if (fCtx.fMaskShader) {
        // As we compose mask filters, use the relative transform T for the inner mask:
        //
        //   maskCTM x T = ctm
        //
        //   => T = Inv(maskCTM) x ctm
        //
        SkMatrix invMaskCTM;
        if (ms && fCtx.fMaskCTM.invert(&invMaskCTM)) {
            const auto relative_transform = SkMatrix::Concat(invMaskCTM, ctm);
            fCtx.fMaskShader = SkShaders::Blend(SkBlendMode::kSrcIn,
                                                std::move(fCtx.fMaskShader),
                                                ms->makeWithLocalMatrix(relative_transform));
        }
    } else {
        fCtx.fMaskShader = std::move(ms);
        fCtx.fMaskCTM    = ctm;
    }
 
    return std::move(*this);
}

modulateOpacity()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::modulateOpacity

(

float

opacity

)

Definition at line 140 of file SkSGRenderNode.cpp.

                                                            {
    SkASSERT(opacity >= 0 && opacity <= 1);
    fCtx.fOpacity *= opacity;
    return std::move(*this);
}

modulateShader()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::modulateShader	(	sk_sp< SkShader >	sh,
		const SkMatrix &	shader_ctm
	)

Definition at line 153 of file SkSGRenderNode.cpp.

                                                                                            {
    // Topmost shader takes precedence.
    if (!fCtx.fShader) {
        fCtx.fShader = std::move(sh);
        fCtx.fShaderCTM = shader_ctm;
    }
 
    return std::move(*this);
}

operator const RenderContext *()

sksg::RenderNode::ScopedRenderContext::operator const RenderContext * ( ) const

inline

Definition at line 94 of file SkSGRenderNode.h.

{ return &fCtx; }

operator->()

const RenderContext * sksg::RenderNode::ScopedRenderContext::operator-> ( ) const

inline

Definition at line 95 of file SkSGRenderNode.h.

{ return &fCtx; }

operator=()

ScopedRenderContext & sksg::RenderNode::ScopedRenderContext::operator= ( ScopedRenderContext &&  that )

inline

Definition at line 82 of file SkSGRenderNode.h.

                                                                   {
            fCanvas       = that.fCanvas;
            fCtx          = std::move(that.fCtx);
            fMaskShader   = std::move(that.fMaskShader);
            fRestoreCount = that.fRestoreCount;
 
            // scope ownership is being transferred
            that.fRestoreCount = -1;
 
            return *this;
        }

setFilterIsolation()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::setFilterIsolation	(	const SkRect &	bounds,
		const SkMatrix &	ctm,
		sk_sp< SkImageFilter >	filter
	)

Definition at line 217 of file SkSGRenderNode.cpp.

                                                                                 {
    if (filter) {
        SkPaint layer_paint;
        fCtx.modulatePaint(ctm, &layer_paint);
        // shaders and image filters are not composable, so we convert the shader to an
        // image filter and blend them together
        if (layer_paint.getShader()) {
            filter = SkImageFilters::Blend(SkBlendMode::kSrcIn, std::move(filter),
            SkImageFilters::Shader(layer_paint.refShader()));
        }
        SkASSERT(!layer_paint.getImageFilter());
        layer_paint.setImageFilter(std::move(filter));
        fCanvas->saveLayer(bounds, &layer_paint);
        fCtx = RenderContext();
    }
 
    return std::move(*this);
}

setIsolation()

RenderNode::ScopedRenderContext && sksg::RenderNode::ScopedRenderContext::setIsolation	(	const SkRect &	bounds,
		const SkMatrix &	ctm,
		bool	do_isolate
	)

Definition at line 194 of file SkSGRenderNode.cpp.

                                                              {
    if (isolation && fCtx.requiresIsolation()) {
        SkPaint layer_paint;
        fCtx.modulatePaint(ctm, &layer_paint, /*is_layer_paint = */true);
        fCanvas->saveLayer(bounds, &layer_paint);
 
        // Fetch the mask shader for restore.
        if (fCtx.fMaskShader) {
            fMaskShader = LocalShader(fCtx.fMaskShader, fCtx.fMaskCTM, ctm);
        }
 
        // Reset only the props applied via isolation layers.
        fCtx.fColorFilter = nullptr;
        fCtx.fMaskShader  = nullptr;
        fCtx.fBlender     = nullptr;
        fCtx.fOpacity     = 1;
    }
 
    return std::move(*this);
}

---

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

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