SkRasterClip Class Reference

#include <SkRasterClip.h>

Public Member Functions
	SkRasterClip ()
	SkRasterClip (const SkIRect &)
	SkRasterClip (const SkRegion &)
	SkRasterClip (const SkRasterClip &)
	SkRasterClip (const SkPath &path, const SkIRect &bounds, bool doAA)
	~SkRasterClip ()
SkRasterClip &	operator= (const SkRasterClip &)
bool	isBW () const
bool	isAA () const
const SkRegion &	bwRgn () const
const SkAAClip &	aaRgn () const
bool	isEmpty () const
bool	isRect () const
bool	isComplex () const
const SkIRect &	getBounds () const
bool	setEmpty ()
bool	setRect (const SkIRect &)
bool	op (const SkIRect &, SkClipOp)
bool	op (const SkRegion &, SkClipOp)
bool	op (const SkRect &, const SkMatrix &matrix, SkClipOp, bool doAA)
bool	op (const SkRRect &, const SkMatrix &matrix, SkClipOp, bool doAA)
bool	op (const SkPath &, const SkMatrix &matrix, SkClipOp, bool doAA)
bool	op (sk_sp< SkShader >)
void	translate (int dx, int dy, SkRasterClip *dst) const
bool	quickContains (const SkIRect &rect) const
bool	quickReject (const SkIRect &rect) const
void	validate () const
sk_sp< SkShader >	clipShader () const

Detailed Description

Wraps a SkRegion and SkAAClip, so we have a single object that can represent either our BW or antialiased clips.

Definition at line 29 of file SkRasterClip.h.

Constructor & Destructor Documentation

SkRasterClip() [1/5]

SkRasterClip::SkRasterClip

(

)

Definition at line 68 of file SkRasterClip.cpp.

                           {
    fIsBW = true;
    fIsEmpty = true;
    fIsRect = false;
    SkDEBUGCODE(this->validate();)
}

SkRasterClip() [2/5]

SkRasterClip::SkRasterClip ( const SkIRect &  bounds )

explicit

Definition at line 61 of file SkRasterClip.cpp.

                                                : fBW(bounds) {
    fIsBW = true;
    fIsEmpty = this->computeIsEmpty();  // bounds might be empty, so compute
    fIsRect = !fIsEmpty;
    SkDEBUGCODE(this->validate();)
}

SkRasterClip() [3/5]

SkRasterClip::SkRasterClip ( const SkRegion &  rgn )

explicit

Definition at line 54 of file SkRasterClip.cpp.

                                              : fBW(rgn) {
    fIsBW = true;
    fIsEmpty = this->computeIsEmpty();  // bounds might be empty, so compute
    fIsRect = !fIsEmpty;
    SkDEBUGCODE(this->validate();)
}

SkRasterClip() [4/5]

SkRasterClip::SkRasterClip ( const SkRasterClip &  that )

explicit

Definition at line 20 of file SkRasterClip.cpp.

        : fIsBW(that.fIsBW)
        , fIsEmpty(that.fIsEmpty)
        , fIsRect(that.fIsRect)
        , fShader(that.fShader)
{
    AUTO_RASTERCLIP_VALIDATE(that);
 
    if (fIsBW) {
        fBW = that.fBW;
    } else {
        fAA = that.fAA;
    }
 
    SkDEBUGCODE(this->validate();)
}

SkRasterClip() [5/5]

SkRasterClip::SkRasterClip	(	const SkPath &	path,
		const SkIRect &	bounds,
		bool	doAA
	)

Definition at line 75 of file SkRasterClip.cpp.

                                                                               {
    if (doAA) {
        fIsBW = false;
        fAA.setPath(path, bounds, true);
    } else {
        fIsBW = true;
        fBW.setPath(path, SkRegion(bounds));
    }
    fIsEmpty = this->computeIsEmpty();  // bounds might be empty, so compute
    fIsRect = this->computeIsRect();
    SkDEBUGCODE(this->validate();)
}

~SkRasterClip()

SkRasterClip::~SkRasterClip

(

)

Definition at line 88 of file SkRasterClip.cpp.

                            {
    SkDEBUGCODE(this->validate();)
}

Member Function Documentation

aaRgn()

const SkAAClip & SkRasterClip::aaRgn ( ) const

inline

Definition at line 44 of file SkRasterClip.h.

{ SkASSERT(!fIsBW); return fAA; }

bwRgn()

const SkRegion & SkRasterClip::bwRgn ( ) const

inline

Definition at line 43 of file SkRasterClip.h.

{ SkASSERT(fIsBW); return fBW; }

clipShader()

sk_sp< SkShader > SkRasterClip::clipShader ( ) const

inline

Definition at line 94 of file SkRasterClip.h.

{ return fShader; }

getBounds()

const SkIRect & SkRasterClip::getBounds ( ) const

inline

Definition at line 59 of file SkRasterClip.h.

                                     {
        return fIsBW ? fBW.getBounds() : fAA.getBounds();
    }

isAA()

bool SkRasterClip::isAA ( ) const

inline

Definition at line 42 of file SkRasterClip.h.

{ return !fIsBW; }

isBW()

bool SkRasterClip::isBW ( ) const

inline

Definition at line 41 of file SkRasterClip.h.

{ return fIsBW; }

isComplex()

bool SkRasterClip::isComplex ( ) const

inline

Definition at line 56 of file SkRasterClip.h.

                           {
        return fIsBW ? fBW.isComplex() : !fAA.isEmpty();
    }

isEmpty()

bool SkRasterClip::isEmpty ( ) const

inline

Definition at line 46 of file SkRasterClip.h.

                         {
        SkASSERT(this->computeIsEmpty() == fIsEmpty);
        return fIsEmpty;
    }

isRect()

bool SkRasterClip::isRect ( ) const

inline

Definition at line 51 of file SkRasterClip.h.

                        {
        SkASSERT(this->computeIsRect() == fIsRect);
        return fIsRect;
    }

op() [1/6]

bool SkRasterClip::op	(	const SkIRect &	rect,
		SkClipOp	op
	)

Definition at line 115 of file SkRasterClip.cpp.

                                                      {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    if (fIsBW) {
        fBW.op(rect, (SkRegion::Op) op);
    } else {
        fAA.op(rect, op);
    }
    return this->updateCacheAndReturnNonEmpty();
}

op() [2/6]

bool SkRasterClip::op	(	const SkPath &	path,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 185 of file SkRasterClip.cpp.

                                                                                        {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    SkPath devPath;
    path.transform(matrix, &devPath);
 
    // Since op is either intersect or difference, the clip is always shrinking; that means we can
    // always use our current bounds as the limiting factor for region/aaclip operations.
    if (this->isRect() && op == SkClipOp::kIntersect) {
        // However, in the relatively common case of intersecting a new path with a rectangular
        // clip, it's faster to convert the path into a region/aa-mask in place than evaluate the
        // actual intersection. See skbug.com/12398
        if (doAA && fIsBW) {
            this->convertToAA();
        }
        if (fIsBW) {
            fBW.setPath(devPath, SkRegion(this->getBounds()));
        } else {
            fAA.setPath(devPath, this->getBounds(), doAA);
        }
        return this->updateCacheAndReturnNonEmpty();
    } else {
        return this->op(SkRasterClip(devPath, this->getBounds(), doAA), op);
    }
}

op() [3/6]

bool SkRasterClip::op	(	const SkRect &	localRect,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 152 of file SkRasterClip.cpp.

                                                                                             {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    const bool isScaleTrans = matrix.isScaleTranslate();
    if (!isScaleTrans) {
        return this->op(SkPath::Rect(localRect), matrix, op, doAA);
    }
 
    SkRect devRect = matrix.mapRect(localRect);
    if (fIsBW && doAA) {
        // check that the rect really needs aa, or is it close enought to
        // integer boundaries that we can just treat it as a BW rect?
        if (nearly_integral(devRect.fLeft) && nearly_integral(devRect.fTop) &&
            nearly_integral(devRect.fRight) && nearly_integral(devRect.fBottom)) {
            doAA = false;
        }
    }
 
    if (fIsBW && !doAA) {
        (void)fBW.op(devRect.round(), (SkRegion::Op) op);
    } else {
        if (fIsBW) {
            this->convertToAA();
        }
        (void)fAA.op(devRect, op, doAA);
    }
    return this->updateCacheAndReturnNonEmpty();
}

op() [4/6]

bool SkRasterClip::op	(	const SkRegion &	rgn,
		SkClipOp	op
	)

Definition at line 126 of file SkRasterClip.cpp.

                                                      {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    if (fIsBW) {
        (void)fBW.op(rgn, (SkRegion::Op) op);
    } else {
        SkAAClip tmp;
        tmp.setRegion(rgn);
        (void)fAA.op(tmp, op);
    }
    return this->updateCacheAndReturnNonEmpty();
}

op() [5/6]

bool SkRasterClip::op	(	const SkRRect &	rrect,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 181 of file SkRasterClip.cpp.

                                                                                          {
    return this->op(SkPath::RRect(rrect), matrix, op, doAA);
}

op() [6/6]

bool SkRasterClip::op

(

sk_sp< SkShader >

sh

)

Definition at line 211 of file SkRasterClip.cpp.

                                        {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    if (!fShader) {
        fShader = sh;
    } else {
        fShader = SkShaders::Blend(SkBlendMode::kSrcIn, sh, fShader);
    }
    return !this->isEmpty();
}

operator=()

SkRasterClip & SkRasterClip::operator=

(

const SkRasterClip &

that

)

Definition at line 37 of file SkRasterClip.cpp.

                                                              {
    AUTO_RASTERCLIP_VALIDATE(that);
 
    fIsBW = that.fIsBW;
    if (fIsBW) {
        fBW = that.fBW;
    } else {
        fAA = that.fAA;
    }
 
    fIsEmpty = that.isEmpty();
    fIsRect = that.isRect();
    fShader = that.fShader;
    SkDEBUGCODE(this->validate();)
    return *this;
}

quickContains()

bool SkRasterClip::quickContains ( const SkIRect &  rect ) const

inline

Definition at line 75 of file SkRasterClip.h.

                                                  {
        return fIsBW ? fBW.quickContains(rect) : fAA.quickContains(rect);
    }

quickReject()

bool SkRasterClip::quickReject ( const SkIRect &  rect ) const

inline

Return true if this region is empty, or if the specified rectangle does not intersect the region. Returning false is not a guarantee that they intersect, but returning true is a guarantee that they do not.

Definition at line 84 of file SkRasterClip.h.

                                                {
        return !SkIRect::Intersects(this->getBounds(), rect);
    }

setEmpty()

bool SkRasterClip::setEmpty

(

)

Definition at line 92 of file SkRasterClip.cpp.

                            {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    fIsBW = true;
    fBW.setEmpty();
    fAA.setEmpty();
    fIsEmpty = true;
    fIsRect = false;
    return false;
}

setRect()

bool SkRasterClip::setRect

(

const SkIRect &

rect

)

Definition at line 103 of file SkRasterClip.cpp.

                                              {
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    fIsBW = true;
    fAA.setEmpty();
    fIsRect = fBW.setRect(rect);
    fIsEmpty = !fIsRect;
    return fIsRect;
}

translate()

void SkRasterClip::translate	(	int	dx,
		int	dy,
		SkRasterClip *	dst
	)		const

Definition at line 246 of file SkRasterClip.cpp.

                                                                    {
    if (nullptr == dst) {
        return;
    }
 
    AUTO_RASTERCLIP_VALIDATE(*this);
 
    if (this->isEmpty()) {
        dst->setEmpty();
        return;
    }
    if (0 == (dx | dy)) {
        *dst = *this;
        return;
    }
 
    dst->fIsBW = fIsBW;
    if (fIsBW) {
        fBW.translate(dx, dy, &dst->fBW);
        dst->fAA.setEmpty();
    } else {
        fAA.translate(dx, dy, &dst->fAA);
        dst->fBW.setEmpty();
    }
    dst->updateCacheAndReturnNonEmpty();
}

validate()

void SkRasterClip::validate ( ) const

inline

Definition at line 91 of file SkRasterClip.h.

{}

---

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

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