GrStencilSettings Class Reference

#include <GrStencilSettings.h>

Classes
struct	Face

Public Member Functions
	GrStencilSettings ()
	GrStencilSettings (const GrUserStencilSettings &user, bool hasStencilClip, int numStencilBits)
	GrStencilSettings (const GrStencilSettings &that)
GrStencilSettings &	operator= (const GrStencilSettings &that)
void	invalidate ()
void	setDisabled ()
void	reset (const GrUserStencilSettings &, bool hasStencilClip, int numStencilBits)
void	reset (const GrStencilSettings &)
bool	isValid () const
bool	isDisabled () const
bool	doesWrite () const
bool	isTwoSided () const
bool	usesWrapOp () const
void	genKey (skgpu::KeyBuilder *b, bool includeRefsAndMasks) const
bool	operator!= (const GrStencilSettings &that) const
bool	operator== (const GrStencilSettings &) const
const Face &	singleSidedFace () const
const Face &	postOriginCWFace (GrSurfaceOrigin origin) const
const Face &	postOriginCCWFace (GrSurfaceOrigin origin) const

Static Public Member Functions
static const GrUserStencilSettings *	SetClipBitSettings (bool setToInside)

Detailed Description

This class defines concrete stencil settings that map directly to the underlying hardware. It is deduced from user stencil settings, stencil clip status, and the number of bits in the target stencil buffer.

Definition at line 51 of file GrStencilSettings.h.

Constructor & Destructor Documentation

GrStencilSettings() [1/3]

GrStencilSettings::GrStencilSettings ( )

inline

Definition at line 53 of file GrStencilSettings.h.

{ this->setDisabled(); }

GrStencilSettings() [2/3]

GrStencilSettings::GrStencilSettings ( const GrUserStencilSettings &  user, bool  hasStencilClip, int  numStencilBits  )

inline

Definition at line 54 of file GrStencilSettings.h.

                                                                                                  {
        this->reset(user, hasStencilClip, numStencilBits);
    }

GrStencilSettings() [3/3]

GrStencilSettings::GrStencilSettings ( const GrStencilSettings &  that )

inline

Definition at line 57 of file GrStencilSettings.h.

{ this->reset(that); }

Member Function Documentation

doesWrite()

bool GrStencilSettings::doesWrite ( ) const

inline

Definition at line 67 of file GrStencilSettings.h.

                           { SkASSERT(this->isValid());
                             return !(fFlags & kNoModifyStencil_StencilFlag); }

genKey()

void GrStencilSettings::genKey	(	skgpu::KeyBuilder *	b,
		bool	includeRefsAndMasks
	)		const

Definition at line 249 of file GrStencilSettings.cpp.

                                                                         {
    b->addBits(6, fFlags, "stencilFlags");
    if (this->isDisabled()) {
        return;
    }
    if (!this->isTwoSided()) {
        if (includeRefs) {
            b->addBytes(sizeof(Face), &fCWFace, "stencilCWFace");
        } else {
            Face tempFace = fCWFace;
            tempFace.fRef = 0;
            b->addBytes(sizeof(Face), &tempFace, "stencilCWFace");
        }
    } else {
        if (includeRefs) {
            b->addBytes(sizeof(Face), &fCWFace, "stencilCWFace");
            b->addBytes(sizeof(Face), &fCCWFace, "stencilCCWFace");
        } else {
            Face tempFaces[2];
            tempFaces[0] = fCWFace;
            tempFaces[0].fRef = 0;
            tempFaces[1] = fCCWFace;
            tempFaces[1].fRef = 0;
            b->addBytes(sizeof(Face), &tempFaces[0], "stencilCWFace");
            b->addBytes(sizeof(Face), &tempFaces[1], "stencilCCWFace");
        }
    }
    // We rely on GrStencilSettings::Face being tightly packed for the key to be reliable.
    static_assert(0 == offsetof(Face, fRef));
    static_assert(2 == sizeof(Face::fRef));
    static_assert(2 == offsetof(Face, fTest));
    static_assert(2 == sizeof(Face::fTest));
    static_assert(4 == offsetof(Face, fTestMask));
    static_assert(2 == sizeof(Face::fTestMask));
    static_assert(6 == offsetof(Face, fPassOp));
    static_assert(1 == sizeof(Face::fPassOp));
    static_assert(7 == offsetof(Face, fFailOp));
    static_assert(1 == sizeof(Face::fFailOp));
    static_assert(8 == offsetof(Face, fWriteMask));
    static_assert(2 == sizeof(Face::fWriteMask));
    static_assert(10 == sizeof(Face));
}

invalidate()

void GrStencilSettings::invalidate ( )

inline

Definition at line 60 of file GrStencilSettings.h.

{ fFlags |= kInvalid_PrivateFlag; }

isDisabled()

bool GrStencilSettings::isDisabled ( ) const

inline

Definition at line 66 of file GrStencilSettings.h.

{ SkASSERT(this->isValid()); return fFlags & kDisabled_StencilFlag; }

isTwoSided()

bool GrStencilSettings::isTwoSided ( ) const

inline

Definition at line 69 of file GrStencilSettings.h.

                            { SkASSERT(this->isValid());
                              return !(fFlags & kSingleSided_StencilFlag); }

isValid()

bool GrStencilSettings::isValid ( ) const

inline

Definition at line 65 of file GrStencilSettings.h.

{ return !(fFlags & kInvalid_PrivateFlag); }

operator!=()

bool GrStencilSettings::operator!= ( const GrStencilSettings &  that ) const

inline

Definition at line 76 of file GrStencilSettings.h.

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

operator=()

GrStencilSettings & GrStencilSettings::operator= ( const GrStencilSettings &  that )

inline

Definition at line 58 of file GrStencilSettings.h.

{ this->reset(that); return *this; }

operator==()

bool GrStencilSettings::operator==

(

const GrStencilSettings &

that

)

const

Definition at line 73 of file GrStencilSettings.cpp.

                                                                      {
    if ((kInvalid_PrivateFlag | kDisabled_StencilFlag) & (fFlags | that.fFlags)) {
        // At least one is invalid and/or disabled.
        if (kInvalid_PrivateFlag & (fFlags | that.fFlags)) {
            return false; // We never allow invalid stencils to be equal.
        }
        // They're only equal if both are disabled.
        return kDisabled_StencilFlag & (fFlags & that.fFlags);
    }
    if (kSingleSided_StencilFlag & (fFlags & that.fFlags)) {
        return 0 == memcmp(&fCWFace, &that.fCWFace, sizeof(Face)); // Both are single sided.
    } else if (kSingleSided_StencilFlag & (fFlags | that.fFlags)) {
        return false;
    } else {
        return 0 == memcmp(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
        static_assert(sizeof(Face) ==
                      offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
    }
    // memcmp relies on GrStencilSettings::Face being tightly packed.
    static_assert(0 == offsetof(Face, fRef));
    static_assert(2 == sizeof(Face::fRef));
    static_assert(2 == offsetof(Face, fTest));
    static_assert(2 == sizeof(Face::fTest));
    static_assert(4 == offsetof(Face, fTestMask));
    static_assert(2 == sizeof(Face::fTestMask));
    static_assert(6 == offsetof(Face, fPassOp));
    static_assert(1 == sizeof(Face::fPassOp));
    static_assert(7 == offsetof(Face, fFailOp));
    static_assert(1 == sizeof(Face::fFailOp));
    static_assert(8 == offsetof(Face, fWriteMask));
    static_assert(2 == sizeof(Face::fWriteMask));
    static_assert(10 == sizeof(Face));
}

postOriginCCWFace()

const Face & GrStencilSettings::postOriginCCWFace ( GrSurfaceOrigin  origin ) const

inline

Definition at line 99 of file GrStencilSettings.h.

                                                                {
        SkASSERT(this->isTwoSided());
        return (kTopLeft_GrSurfaceOrigin == origin) ? fCCWFace : fCWFace;
    }

postOriginCWFace()

const Face & GrStencilSettings::postOriginCWFace ( GrSurfaceOrigin  origin ) const

inline

Definition at line 92 of file GrStencilSettings.h.

                                                               {
        SkASSERT(this->isTwoSided());
        return (kTopLeft_GrSurfaceOrigin == origin) ? fCWFace : fCCWFace;
    }

reset() [1/2]

void GrStencilSettings::reset

(

const GrStencilSettings &

that

)

Definition at line 59 of file GrStencilSettings.cpp.

                                                           {
    fFlags = that.fFlags;
    if ((kInvalid_PrivateFlag | kDisabled_StencilFlag) & fFlags) {
        return;
    }
    if (!this->isTwoSided()) {
        memcpy(&fCWFace, &that.fCWFace, sizeof(Face));
    } else {
        memcpy(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
        static_assert(sizeof(Face) ==
                      offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
    }
}

reset() [2/2]

void GrStencilSettings::reset	(	const GrUserStencilSettings &	user,
		bool	hasStencilClip,
		int	numStencilBits
	)

Definition at line 30 of file GrStencilSettings.cpp.

                                                  {
    uint16_t cwFlags = user.fCWFlags[hasStencilClip];
    if (cwFlags & kSingleSided_StencilFlag) {
        SkASSERT(cwFlags == user.fCCWFlags[hasStencilClip]);
        fFlags = cwFlags;
        if (!this->isDisabled()) {
            fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
        }
        return;
    }
 
    uint16_t ccwFlags = user.fCCWFlags[hasStencilClip];
    fFlags = cwFlags & ccwFlags;
    if (this->isDisabled()) {
        return;
    }
    if (!(cwFlags & kDisabled_StencilFlag)) {
        fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
    } else {
        fCWFace.setDisabled();
    }
    if (!(ccwFlags & kDisabled_StencilFlag)) {
        fCCWFace.reset(user.fCCWFace, hasStencilClip, numStencilBits);
    } else {
        fCCWFace.setDisabled();
    }
}

SetClipBitSettings()

const GrUserStencilSettings * GrStencilSettings::SetClipBitSettings ( bool  setToInside )

static

Gets the user stencil settings to directly set the clip bit.

Definition at line 245 of file GrStencilSettings.cpp.

                                                                                   {
    return setToInside ? &gSetStencilClipBit : &gZeroStencilClipBit;
}

setDisabled()

void GrStencilSettings::setDisabled ( )

inline

Definition at line 61 of file GrStencilSettings.h.

{ fFlags = kAll_StencilFlags; }

singleSidedFace()

const Face & GrStencilSettings::singleSidedFace ( ) const

inline

Definition at line 84 of file GrStencilSettings.h.

                                        {
        SkASSERT(!this->isDisabled());
        SkASSERT(!this->isTwoSided());
        return fCWFace;
    }

usesWrapOp()

bool GrStencilSettings::usesWrapOp ( ) const

inline

Definition at line 71 of file GrStencilSettings.h.

                            { SkASSERT(this->isValid());
                              return !(fFlags & kNoWrapOps_StencilFlag); }

---

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

• third_party/skia/src/gpu/ganesh/GrStencilSettings.h
• third_party/skia/src/gpu/ganesh/GrStencilSettings.cpp