AutoLayerForImageFilter Class Reference

#include <SkCanvasPriv.h>

Public Member Functions
	AutoLayerForImageFilter (SkCanvas *canvas, const SkPaint &paint, const SkRect *rawBounds, bool skipMaskFilterLayer)
	AutoLayerForImageFilter (const AutoLayerForImageFilter &)=delete
AutoLayerForImageFilter &	operator= (const AutoLayerForImageFilter &)=delete
	AutoLayerForImageFilter (AutoLayerForImageFilter &&)
AutoLayerForImageFilter &	operator= (AutoLayerForImageFilter &&)
	~AutoLayerForImageFilter ()
const SkPaint &	paint () const
void	addMaskFilterLayer (const SkRect *drawBounds)

Detailed Description

We implement ImageFilters and MaskFilters for a given draw by creating a layer, then applying the filter to the pixels of that layer (its backing surface/image), and then we call restore() to blend that layer to the main canvas.

If the paint has neither an image filter nor a mask filter, there will be no layer and paint() returns the original without modification.

NOTE: This works by assuming all sources of color and shading are represented by the SkPaint. Operations like drawImageRect must convert to an equivalent drawRect call if there's a mask filter, or otherwise ensure there are no mask filters (e.g. drawAtlas).

Definition at line 122 of file SkCanvasPriv.h.

Constructor & Destructor Documentation

AutoLayerForImageFilter() [1/3]

AutoLayerForImageFilter::AutoLayerForImageFilter	(	SkCanvas *	canvas,
		const SkPaint &	paint,
		const SkRect *	rawBounds,
		bool	skipMaskFilterLayer
	)

Definition at line 162 of file SkCanvasPriv.cpp.

            : fPaint(paint)
            , fCanvas(canvas)
            , fTempLayersForFilters(0) {
    SkDEBUGCODE(fSaveCount = canvas->getSaveCount();)
 
    // Depending on the original paint, this will add 0, 1, or 2 layers that apply the
    // filter effects to a temporary layer that rasterized the remaining effects. Image filters
    // are applied to the result of any mask filter, so its layer is added first in the stack.
    //
    // If present on the original paint, the image filter layer's restore paint steals the blender
    // and the image filter so that the draw's paint will never have an image filter.
    if (fPaint.getImageFilter() && !SkCanvasPriv::ImageToColorFilter(&fPaint)) {
        this->addImageFilterLayer(rawBounds);
    }
 
    // If present on the original paint, the mask filter layer's restore paint steals all shading
    // effects and the draw's paint shading is updated to draw a solid opaque color (thus encoding
    // coverage into the alpha channel). The draw's paint preserves all geometric effects that have
    // to be applied before the mask filter. The layer's restore paint adds an image filter
    // representing the mask filter.
    if (fPaint.getMaskFilter() && !skipMaskFilterLayer) {
        this->addMaskFilterLayer(rawBounds);
    }
 
   // When the original paint has both an image filter and a mask filter, this will create two
   // internal layers and perform two restores when finished. This actually creates one fewer
   // offscreen passes compared to directly composing the mask filter's output with an
   // SkImageFilters::Shader node and passing that into the rest of the image filter.
}

AutoLayerForImageFilter() [2/3]

AutoLayerForImageFilter::AutoLayerForImageFilter ( const AutoLayerForImageFilter &  )

delete

AutoLayerForImageFilter() [3/3]

AutoLayerForImageFilter::AutoLayerForImageFilter

(

AutoLayerForImageFilter &&

other

)

Definition at line 205 of file SkCanvasPriv.cpp.

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

~AutoLayerForImageFilter()

AutoLayerForImageFilter::~AutoLayerForImageFilter

(

)

Definition at line 196 of file SkCanvasPriv.cpp.

                                                  {
    for (int i = 0; i < fTempLayersForFilters; ++i) {
        fCanvas->fSaveCount -= 1;
        fCanvas->internalRestore();
    }
    // Negative save count occurs when this layer was moved.
    SkASSERT(fSaveCount < 0 || fCanvas->getSaveCount() == fSaveCount);
}

Member Function Documentation

addMaskFilterLayer()

void AutoLayerForImageFilter::addMaskFilterLayer

(

const SkRect *

drawBounds

)

Definition at line 241 of file SkCanvasPriv.cpp.

                                                                         {
    // Shouldn't be adding a layer if there was no mask filter to begin with.
    SkASSERT(fPaint.getMaskFilter());
 
    // Image filters are evaluated after mask filters so any filter should have been converted to
    // a layer and removed from fPaint already.
    SkASSERT(!fPaint.getImageFilter());
 
    // TODO: Eventually all SkMaskFilters will implement this method so this can switch to an assert
    sk_sp<SkImageFilter> maskFilterAsImageFilter =
            as_MFB(fPaint.getMaskFilter())->asImageFilter(fCanvas->getTotalMatrix());
    if (!maskFilterAsImageFilter) {
        // This is a legacy mask filter that can be handled by raster and Ganesh directly, but will
        // be ignored by Graphite. Return now, leaving the paint with the mask filter so that the
        // underlying SkDevice can handle it if it will.
        return;
    }
 
    // The restore paint for the coverage layer takes over all shading effects that had been on the
    // original paint, which will be applied to the alpha-only output image from the mask filter
    // converted to an image filter.
    SkPaint restorePaint;
    restorePaint.setColor4f(fPaint.getColor4f());
    restorePaint.setShader(fPaint.refShader());
    restorePaint.setColorFilter(fPaint.refColorFilter());
    restorePaint.setBlender(fPaint.refBlender());
    restorePaint.setDither(fPaint.isDither());
    restorePaint.setImageFilter(maskFilterAsImageFilter);
 
    // Remove all shading effects from the "working" paint so that the layer's alpha channel
    // will correspond to the coverage. This leaves the original style and AA settings that
    // contribute to coverage (including any path effect).
    fPaint.setColor4f(SkColors::kWhite);
    fPaint.setShader(nullptr);
    fPaint.setColorFilter(nullptr);
    fPaint.setMaskFilter(nullptr);
    fPaint.setDither(false);
    fPaint.setBlendMode(SkBlendMode::kSrcOver);
 
    this->addLayer(restorePaint, drawBounds, /*coverageOnly=*/true);
}

operator=() [1/2]

AutoLayerForImageFilter & AutoLayerForImageFilter::operator=

(

AutoLayerForImageFilter &&

other

)

Definition at line 209 of file SkCanvasPriv.cpp.

                                                                                           {
    fPaint = std::move(other.fPaint);
    fCanvas = other.fCanvas;
    fTempLayersForFilters = other.fTempLayersForFilters;
    SkDEBUGCODE(fSaveCount = other.fSaveCount;)
 
    other.fTempLayersForFilters = 0;
    SkDEBUGCODE(other.fSaveCount = -1;)
 
    return *this;
}

operator=() [2/2]

AutoLayerForImageFilter & AutoLayerForImageFilter::operator= ( const AutoLayerForImageFilter &  )

delete

paint()

const SkPaint & AutoLayerForImageFilter::paint ( ) const

inline

Definition at line 144 of file SkCanvasPriv.h.

{ return fPaint; }

---

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

• third_party/skia/src/core/SkCanvasPriv.h
• third_party/skia/src/core/SkCanvasPriv.cpp