SkClipStack Class Reference

#include <SkClipStack.h>

Classes
class	AutoRestore
class	B2TIter
class	Element
class	Iter

Public Types
enum	BoundsType { kNormal_BoundsType , kInsideOut_BoundsType }

Public Member Functions
	SkClipStack ()
	SkClipStack (void *storage, size_t size)
	SkClipStack (const SkClipStack &b)
	~SkClipStack ()
SkClipStack &	operator= (const SkClipStack &b)
bool	operator== (const SkClipStack &b) const
bool	operator!= (const SkClipStack &b) const
void	reset ()
int	getSaveCount () const
void	save ()
void	restore ()
void	getBounds (SkRect *canvFiniteBound, BoundsType *boundType, bool *isIntersectionOfRects=nullptr) const
SkRect	bounds (const SkIRect &deviceBounds) const
bool	isEmpty (const SkIRect &deviceBounds) const
bool	quickContains (const SkRect &devRect) const
bool	quickContains (const SkRRect &devRRect) const
void	clipDevRect (const SkIRect &ir, SkClipOp op)
void	clipRect (const SkRect &, const SkMatrix &matrix, SkClipOp, bool doAA)
void	clipRRect (const SkRRect &, const SkMatrix &matrix, SkClipOp, bool doAA)
void	clipPath (const SkPath &, const SkMatrix &matrix, SkClipOp, bool doAA)
void	clipShader (sk_sp< SkShader >)
void	clipEmpty ()
void	replaceClip (const SkRect &devRect, bool doAA)
bool	isWideOpen () const
bool	isRRect (const SkRect &bounds, SkRRect *rrect, bool *aa) const
uint32_t	getTopmostGenID () const
void	getConservativeBounds (int offsetX, int offsetY, int maxWidth, int maxHeight, SkRect *devBounds, bool *isIntersectionOfRects=nullptr) const

Static Public Attributes
static const uint32_t	kInvalidGenID = 0
static const uint32_t	kEmptyGenID = 1
static const uint32_t	kWideOpenGenID = 2

Friends
class	Iter

Detailed Description

Definition at line 32 of file SkClipStack.h.

Member Enumeration Documentation

BoundsType

enum SkClipStack::BoundsType

Enumerator
kNormal_BoundsType
kInsideOut_BoundsType

Definition at line 34 of file SkClipStack.h.

                    {
        // The bounding box contains all the pixels that can be written to
        kNormal_BoundsType,
        // The bounding box contains all the pixels that cannot be written to.
        // The real bound extends out to infinity and all the pixels outside
        // of the bound can be written to. Note that some of the pixels inside
        // the bound may also be writeable but all pixels that cannot be
        // written to are guaranteed to be inside.
        kInsideOut_BoundsType
    };

Constructor & Destructor Documentation

SkClipStack() [1/3]

SkClipStack::SkClipStack

(

)

Definition at line 510 of file SkClipStack.cpp.

    : fDeque(sizeof(Element), kDefaultElementAllocCnt)
    , fSaveCount(0) {
}

SkClipStack() [2/3]

SkClipStack::SkClipStack	(	void *	storage,
		size_t	size
	)

Definition at line 515 of file SkClipStack.cpp.

    : fDeque(sizeof(Element), storage, size, kDefaultElementAllocCnt)
    , fSaveCount(0) {
}

SkClipStack() [3/3]

SkClipStack::SkClipStack

(

const SkClipStack &

b

)

Definition at line 520 of file SkClipStack.cpp.

    : fDeque(sizeof(Element), kDefaultElementAllocCnt) {
    *this = b;
}

~SkClipStack()

SkClipStack::~SkClipStack

(

)

Definition at line 525 of file SkClipStack.cpp.

                          {
    reset();
}

Member Function Documentation

bounds()

SkRect SkClipStack::bounds

(

const SkIRect &

deviceBounds

)

const

Definition at line 601 of file SkClipStack.cpp.

                                                            {
    // TODO: optimize this.
    SkRect r;
    SkClipStack::BoundsType bounds;
    this->getBounds(&r, &bounds);
    if (bounds == SkClipStack::kInsideOut_BoundsType) {
        return SkRect::Make(deviceBounds);
    }
    return r.intersect(SkRect::Make(deviceBounds)) ? r : SkRect::MakeEmpty();
}

clipDevRect()

void SkClipStack::clipDevRect ( const SkIRect &  ir, SkClipOp  op  )

inline

Definition at line 343 of file SkClipStack.h.

                                                     {
        SkRect r;
        r.set(ir);
        this->clipRect(r, SkMatrix::I(), op, false);
    }

clipEmpty()

void SkClipStack::clipEmpty

(

)

Definition at line 773 of file SkClipStack.cpp.

                            {
    Element* element = (Element*) fDeque.back();
 
    if (element && element->canBeIntersectedInPlace(fSaveCount, SkClipOp::kIntersect)) {
        element->setEmpty();
    }
    new (fDeque.push_back()) Element(fSaveCount);
 
    ((Element*)fDeque.back())->fGenID = kEmptyGenID;
}

clipPath()

void SkClipStack::clipPath	(	const SkPath &	path,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 757 of file SkClipStack.cpp.

                                      {
    Element element(fSaveCount, path, matrix, op, doAA);
    this->pushElement(element);
}

clipRect()

void SkClipStack::clipRect	(	const SkRect &	rect,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 752 of file SkClipStack.cpp.

                                                                                             {
    Element element(fSaveCount, rect, matrix, op, doAA);
    this->pushElement(element);
}

clipRRect()

void SkClipStack::clipRRect	(	const SkRRect &	rrect,
		const SkMatrix &	matrix,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 747 of file SkClipStack.cpp.

                                                                                                {
    Element element(fSaveCount, rrect, matrix, op, doAA);
    this->pushElement(element);
}

clipShader()

void SkClipStack::clipShader

(

sk_sp< SkShader >

shader

)

Definition at line 763 of file SkClipStack.cpp.

                                                   {
    Element element(fSaveCount, std::move(shader));
    this->pushElement(element);
}

getBounds()

void SkClipStack::getBounds	(	SkRect *	canvFiniteBound,
		BoundsType *	boundType,
		bool *	isIntersectionOfRects = nullptr
	)		const

getBounds places the current finite bound in its first parameter. In its second, it indicates which kind of bound is being returned. If 'canvFiniteBound' is a normal bounding box then it encloses all writeable pixels. If 'canvFiniteBound' is an inside out bounding box then it encloses all the un-writeable pixels and the true/normal bound is the infinite plane. isIntersectionOfRects is an optional parameter that is true if 'canvFiniteBound' resulted from an intersection of rects.

Definition at line 615 of file SkClipStack.cpp.

                                                               {
    SkASSERT(canvFiniteBound && boundType);
 
    const Element* element = (const Element*)fDeque.back();
 
    if (nullptr == element) {
        // the clip is wide open - the infinite plane w/ no pixels un-writeable
        canvFiniteBound->setEmpty();
        *boundType = kInsideOut_BoundsType;
        if (isIntersectionOfRects) {
            *isIntersectionOfRects = false;
        }
        return;
    }
 
    *canvFiniteBound = element->fFiniteBound;
    *boundType = element->fFiniteBoundType;
    if (isIntersectionOfRects) {
        *isIntersectionOfRects = element->fIsIntersectionOfRects;
    }
}

getConservativeBounds()

void SkClipStack::getConservativeBounds	(	int	offsetX,
		int	offsetY,
		int	maxWidth,
		int	maxHeight,
		SkRect *	devBounds,
		bool *	isIntersectionOfRects = nullptr
	)		const

GetConservativeBounds returns a conservative bound of the current clip. Since this could be the infinite plane (if inverse fills were involved) the maxWidth and maxHeight parameters can be used to limit the returned bound to the expected drawing area. Similarly, the offsetX and offsetY parameters allow the caller to offset the returned bound to account for translated drawing areas (i.e., those resulting from a saveLayer). For finite bounds, the translation (+offsetX, +offsetY) is applied before the clamp to the maximum rectangle: [0,maxWidth) x [0,maxHeight). isIntersectionOfRects is an optional parameter that is true when 'devBounds' is the result of an intersection of rects. In this case 'devBounds' is the exact answer/clip.

Definition at line 846 of file SkClipStack.cpp.

                                                                           {
    SkASSERT(devBounds);
 
    devBounds->setLTRB(0, 0,
                       SkIntToScalar(maxWidth), SkIntToScalar(maxHeight));
 
    SkRect temp;
    SkClipStack::BoundsType boundType;
 
    // temp starts off in canvas space here
    this->getBounds(&temp, &boundType, isIntersectionOfRects);
    if (SkClipStack::kInsideOut_BoundsType == boundType) {
        return;
    }
 
    // but is converted to device space here
    temp.offset(SkIntToScalar(offsetX), SkIntToScalar(offsetY));
 
    if (!devBounds->intersect(temp)) {
        devBounds->setEmpty();
    }
}

getSaveCount()

int SkClipStack::getSaveCount ( ) const

inline

Definition at line 289 of file SkClipStack.h.

{ return fSaveCount; }

getTopmostGenID()

uint32_t SkClipStack::getTopmostGenID

(

)

const

Definition at line 941 of file SkClipStack.cpp.

                                            {
    if (fDeque.empty()) {
        return kWideOpenGenID;
    }
 
    const Element* back = static_cast<const Element*>(fDeque.back());
    if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty() &&
        Element::DeviceSpaceType::kShader != back->fDeviceSpaceType) {
        return kWideOpenGenID;
    }
 
    return back->getGenID();
}

isEmpty()

bool SkClipStack::isEmpty

(

const SkIRect &

deviceBounds

)

const

Definition at line 613 of file SkClipStack.cpp.

{ return this->bounds(r).isEmpty(); }

isRRect()

bool SkClipStack::isRRect	(	const SkRect &	bounds,
		SkRRect *	rrect,
		bool *	aa
	)		const

This method quickly and conservatively determines whether the entire stack is equivalent to intersection with a rrect given a bounds, where the rrect must not contain the entire bounds.

Parameters

bounds	A bounds on what will be drawn through the clip. The clip only need be equivalent to a intersection with a rrect for draws within the bounds. The returned rrect must intersect the bounds but need not be contained by the bounds.
rrect	If return is true rrect will contain the rrect equivalent to the stack.
aa	If return is true aa will indicate whether the equivalent rrect clip is antialiased.

Returns

true if the stack is equivalent to a single rrect intersect clip, false otherwise.

Definition at line 874 of file SkClipStack.cpp.

                                                                              {
    const Element* back = static_cast<const Element*>(fDeque.back());
    if (!back) {
        // TODO: return bounds?
        return false;
    }
    // First check if the entire stack is known to be a rect by the top element.
    if (back->fIsIntersectionOfRects && back->fFiniteBoundType == BoundsType::kNormal_BoundsType) {
        rrect->setRect(back->fFiniteBound);
        *aa = back->isAA();
        return true;
    }
 
    if (back->getDeviceSpaceType() != SkClipStack::Element::DeviceSpaceType::kRect &&
        back->getDeviceSpaceType() != SkClipStack::Element::DeviceSpaceType::kRRect) {
        return false;
    }
    if (back->isReplaceOp()) {
        *rrect = back->asDeviceSpaceRRect();
        *aa = back->isAA();
        return true;
    }
 
    if (back->getOp() == SkClipOp::kIntersect) {
        SkRect backBounds;
        if (!backBounds.intersect(bounds, back->asDeviceSpaceRRect().rect())) {
            return false;
        }
        // We limit to 17 elements. This means the back element will be bounds checked at most 16
        // times if it is an rrect.
        int cnt = fDeque.count();
        if (cnt > 17) {
            return false;
        }
        if (cnt > 1) {
            SkDeque::Iter iter(fDeque, SkDeque::Iter::kBack_IterStart);
            SkAssertResult(static_cast<const Element*>(iter.prev()) == back);
            while (const Element* prior = (const Element*)iter.prev()) {
                // TODO: Once expanding clip ops are removed, this is equiv. to op == kDifference
                if ((prior->getOp() != SkClipOp::kIntersect && !prior->isReplaceOp()) ||
                    !prior->contains(backBounds)) {
                    return false;
                }
                if (prior->isReplaceOp()) {
                    break;
                }
            }
        }
        *rrect = back->asDeviceSpaceRRect();
        *aa = back->isAA();
        return true;
    }
    return false;
}

isWideOpen()

bool SkClipStack::isWideOpen ( ) const

inline

isWideOpen returns true if the clip state corresponds to the infinite plane (i.e., draws are not limited at all)

Definition at line 361 of file SkClipStack.h.

{ return this->getTopmostGenID() == kWideOpenGenID; }

operator!=()

bool SkClipStack::operator!= ( const SkClipStack &  b ) const

inline

Definition at line 285 of file SkClipStack.h.

{ return !(*this == b); }

operator=()

SkClipStack & SkClipStack::operator=

(

const SkClipStack &

b

)

Definition at line 529 of file SkClipStack.cpp.

                                                        {
    if (this == &b) {
        return *this;
    }
    reset();
 
    fSaveCount = b.fSaveCount;
    SkDeque::F2BIter recIter(b.fDeque);
    for (const Element* element = (const Element*)recIter.next();
         element != nullptr;
         element = (const Element*)recIter.next()) {
        new (fDeque.push_back()) Element(*element);
    }
 
    return *this;
}

operator==()

bool SkClipStack::operator==

(

const SkClipStack &

b

)

const

Definition at line 546 of file SkClipStack.cpp.

                                                       {
    if (this->getTopmostGenID() == b.getTopmostGenID()) {
        return true;
    }
    if (fSaveCount != b.fSaveCount ||
        fDeque.count() != b.fDeque.count()) {
        return false;
    }
    SkDeque::F2BIter myIter(fDeque);
    SkDeque::F2BIter bIter(b.fDeque);
    const Element* myElement = (const Element*)myIter.next();
    const Element* bElement = (const Element*)bIter.next();
 
    while (myElement != nullptr && bElement != nullptr) {
        if (*myElement != *bElement) {
            return false;
        }
        myElement = (const Element*)myIter.next();
        bElement = (const Element*)bIter.next();
    }
    return myElement == nullptr && bElement == nullptr;
}

quickContains() [1/2]

bool SkClipStack::quickContains ( const SkRect &  devRect ) const

inline

Returns true if the input (r)rect in device space is entirely contained by the clip. A return value of false does not guarantee that the (r)rect is not contained by the clip.

Definition at line 335 of file SkClipStack.h.

                                                    {
        return this->isWideOpen() || this->internalQuickContains(devRect);
    }

quickContains() [2/2]

bool SkClipStack::quickContains ( const SkRRect &  devRRect ) const

inline

Definition at line 339 of file SkClipStack.h.

                                                      {
        return this->isWideOpen() || this->internalQuickContains(devRRect);
    }

replaceClip()

void SkClipStack::replaceClip	(	const SkRect &	devRect,
		bool	doAA
	)

Definition at line 768 of file SkClipStack.cpp.

                                                           {
    Element element(fSaveCount, rect, doAA);
    this->pushElement(element);
}

reset()

void SkClipStack::reset

(

)

Definition at line 569 of file SkClipStack.cpp.

                        {
    // We used a placement new for each object in fDeque, so we're responsible
    // for calling the destructor on each of them as well.
    while (!fDeque.empty()) {
        Element* element = (Element*)fDeque.back();
        element->~Element();
        fDeque.pop_back();
    }
 
    fSaveCount = 0;
}

restore()

void SkClipStack::restore

(

)

Definition at line 585 of file SkClipStack.cpp.

                          {
    fSaveCount -= 1;
    restoreTo(fSaveCount);
}

save()

void SkClipStack::save

(

)

Definition at line 581 of file SkClipStack.cpp.

                       {
    fSaveCount += 1;
}

Friends And Related Symbol Documentation

Iter

friend class Iter

friend

Definition at line 488 of file SkClipStack.h.

Member Data Documentation

kEmptyGenID

const uint32_t SkClipStack::kEmptyGenID = 1

static

Definition at line 385 of file SkClipStack.h.

kInvalidGenID

const uint32_t SkClipStack::kInvalidGenID = 0

static

The generation ID has three reserved values to indicate special (potentially ignorable) cases Invalid id that is never returned by SkClipStack. Useful when caching clips based on GenID.

Definition at line 382 of file SkClipStack.h.

kWideOpenGenID

const uint32_t SkClipStack::kWideOpenGenID = 2

static

Definition at line 386 of file SkClipStack.h.

---

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

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