GrStyle Class Reference

#include <GrStyle.h>

Public Types
enum class	Apply { kPathEffectOnly , kPathEffectAndStrokeRec }
enum	KeyFlags { kClosed_KeyFlag = 0x1 , kNoJoins_KeyFlag = 0x2 }

Public Member Functions
	GrStyle ()
	GrStyle (SkStrokeRec::InitStyle initStyle)
	GrStyle (const SkStrokeRec &strokeRec, sk_sp< SkPathEffect > pe)
	GrStyle (const GrStyle &that)=default
	GrStyle (const SkPaint &paint)
	GrStyle (const SkPaint &paint, SkPaint::Style overrideStyle)
GrStyle &	operator= (const GrStyle &that)
void	resetToInitStyle (SkStrokeRec::InitStyle fillOrHairline)
bool	isSimpleFill () const
bool	isSimpleHairline () const
SkPathEffect *	pathEffect () const
sk_sp< SkPathEffect >	refPathEffect () const
bool	hasPathEffect () const
bool	hasNonDashPathEffect () const
bool	isDashed () const
SkScalar	dashPhase () const
int	dashIntervalCnt () const
const SkScalar *	dashIntervals () const
const SkStrokeRec &	strokeRec () const
bool	applies () const
bool	applyPathEffectToPath (SkPath *dst, SkStrokeRec *remainingStoke, const SkPath &src, SkScalar scale) const
bool	applyToPath (SkPath *dst, SkStrokeRec::InitStyle *fillOrHairline, const SkPath &src, SkScalar scale) const
void	adjustBounds (SkRect *dst, const SkRect &src) const

Static Public Member Functions
static const GrStyle &	SimpleFill ()
static const GrStyle &	SimpleHairline ()
static int	KeySize (const GrStyle &, Apply, uint32_t flags=0)
static void	WriteKey (uint32_t *, const GrStyle &, Apply, SkScalar scale, uint32_t flags=0)
static SkScalar	MatrixToScaleFactor (const SkMatrix &matrix)

Detailed Description

Represents the various ways that a GrStyledShape can be styled. It has fill/stroking information as well as an optional path effect. If the path effect represents dashing, the dashing information is extracted from the path effect and stored explicitly.

This will replace GrStrokeInfo as GrStyledShape is deployed.

Definition at line 24 of file GrStyle.h.

Member Enumeration Documentation

Apply

enum class GrStyle::Apply

strong

Enumerator
kPathEffectOnly
kPathEffectAndStrokeRec

Definition at line 44 of file GrStyle.h.

                     {
        kPathEffectOnly,
        kPathEffectAndStrokeRec
    };

KeyFlags

enum GrStyle::KeyFlags

Optional flags for computing keys that may remove unnecessary variation in the key due to style settings that don't affect particular classes of geometry.

Enumerator
kClosed_KeyFlag
kNoJoins_KeyFlag

Definition at line 53 of file GrStyle.h.

                  {
        // The shape being styled has no open contours.
        kClosed_KeyFlag = 0x1,
        // The shape being styled doesn't have any joins and so isn't affected by join type.
        kNoJoins_KeyFlag = 0x2
    };

Constructor & Destructor Documentation

GrStyle() [1/6]

GrStyle::GrStyle ( )

inline

Definition at line 77 of file GrStyle.h.

: GrStyle(SkStrokeRec::kFill_InitStyle) {}

GrStyle() [2/6]

GrStyle::GrStyle ( SkStrokeRec::InitStyle  initStyle )

inlineexplicit

Definition at line 79 of file GrStyle.h.

: fStrokeRec(initStyle) {}

GrStyle() [3/6]

GrStyle::GrStyle ( const SkStrokeRec &  strokeRec, sk_sp< SkPathEffect >  pe  )

inline

Definition at line 81 of file GrStyle.h.

                                                                  : fStrokeRec(strokeRec) {
        this->initPathEffect(std::move(pe));
    }

GrStyle() [4/6]

GrStyle::GrStyle ( const GrStyle &  that )

default

GrStyle() [5/6]

GrStyle::GrStyle ( const SkPaint &  paint )

inlineexplicit

Definition at line 87 of file GrStyle.h.

                                           : fStrokeRec(paint) {
        this->initPathEffect(paint.refPathEffect());
    }

GrStyle() [6/6]

GrStyle::GrStyle ( const SkPaint &  paint, SkPaint::Style  overrideStyle  )

inlineexplicit

Definition at line 91 of file GrStyle.h.

            : fStrokeRec(paint, overrideStyle) {
        this->initPathEffect(paint.refPathEffect());
    }

Member Function Documentation

adjustBounds()

void GrStyle::adjustBounds ( SkRect *  dst, const SkRect &  src  ) const

inline

Given bounds of a path compute the bounds of path with the style applied.

Definition at line 173 of file GrStyle.h.

                                                            {
        *dst = src;
        auto pe = as_PEB(this->pathEffect());
        if (pe && !pe->computeFastBounds(dst)) {
            // Restore dst == src since ComputeFastBounds leaves it undefined when returning false
            *dst = src;
        }
 
        // This may not be the correct SkStrokeRec to use if there's a path effect: skbug.com/5299
        // It happens to work for dashing.
        SkScalar radius = fStrokeRec.getInflationRadius();
        dst->outset(radius, radius);
    }

applies()

bool GrStyle::applies ( ) const

inline

Hairline or fill styles without path effects make no alterations to a geometry.

Definition at line 143 of file GrStyle.h.

                         {
        return this->pathEffect() || (!fStrokeRec.isFillStyle() && !fStrokeRec.isHairlineStyle());
    }

applyPathEffectToPath()

bool GrStyle::applyPathEffectToPath	(	SkPath *	dst,
		SkStrokeRec *	remainingStoke,
		const SkPath &	src,
		SkScalar	scale
	)		const

Applies just the path effect and returns remaining stroke information. This will fail if there is no path effect. dst may or may not have been overwritten on failure. Scale controls geometric approximations made by the path effect. It is typically computed from the view matrix.

Definition at line 163 of file GrStyle.cpp.

                                                                                {
    SkASSERT(dst);
    SkStrokeRec strokeRec = fStrokeRec;
    strokeRec.setResScale(resScale);
    if (!this->applyPathEffect(dst, &strokeRec, src)) {
        return false;
    }
    *remainingStroke = strokeRec;
    return true;
}

applyToPath()

bool GrStyle::applyToPath	(	SkPath *	dst,
		SkStrokeRec::InitStyle *	fillOrHairline,
		const SkPath &	src,
		SkScalar	scale
	)		const

If this succeeds then the result path should be filled or hairlined as indicated by the returned SkStrokeRec::InitStyle value. Will fail if there is no path effect and the strokerec doesn't change the geometry. When this fails the outputs may or may not have been overwritten. Scale controls geometric approximations made by the path effect and stroker. It is typically computed from the view matrix.

Definition at line 175 of file GrStyle.cpp.

                                                   {
    SkASSERT(style);
    SkASSERT(dst);
    SkStrokeRec strokeRec = fStrokeRec;
    strokeRec.setResScale(resScale);
    const SkPath* pathForStrokeRec = &src;
    if (this->applyPathEffect(dst, &strokeRec, src)) {
        pathForStrokeRec = dst;
    } else if (fPathEffect) {
        return false;
    }
    if (strokeRec.needToApply()) {
        if (!strokeRec.applyToPath(dst, *pathForStrokeRec)) {
            return false;
        }
        dst->setIsVolatile(true);
        *style = SkStrokeRec::kFill_InitStyle;
    } else if (!fPathEffect) {
        // Nothing to do for path effect or stroke, fail.
        return false;
    } else {
        SkASSERT(SkStrokeRec::kFill_Style == strokeRec.getStyle() ||
                 SkStrokeRec::kHairline_Style == strokeRec.getStyle());
        *style = strokeRec.getStyle() == SkStrokeRec::kFill_Style
                 ? SkStrokeRec::kFill_InitStyle
                 : SkStrokeRec::kHairline_InitStyle;
    }
    return true;
}

dashIntervalCnt()

int GrStyle::dashIntervalCnt ( ) const

inline

Definition at line 131 of file GrStyle.h.

                                {
        SkASSERT(this->isDashed());
        return fDashInfo.fIntervals.count();
    }

dashIntervals()

const SkScalar * GrStyle::dashIntervals ( ) const

inline

Definition at line 135 of file GrStyle.h.

                                          {
        SkASSERT(this->isDashed());
        return fDashInfo.fIntervals.get();
    }

dashPhase()

SkScalar GrStyle::dashPhase ( ) const

inline

Definition at line 127 of file GrStyle.h.

                               {
        SkASSERT(this->isDashed());
        return fDashInfo.fPhase;
    }

hasNonDashPathEffect()

bool GrStyle::hasNonDashPathEffect ( ) const

inline

Definition at line 124 of file GrStyle.h.

{ return fPathEffect.get() && !this->isDashed(); }

hasPathEffect()

bool GrStyle::hasPathEffect ( ) const

inline

Definition at line 122 of file GrStyle.h.

{ return SkToBool(fPathEffect.get()); }

isDashed()

bool GrStyle::isDashed ( ) const

inline

Definition at line 126 of file GrStyle.h.

{ return SkPathEffect::kDash_DashType == fDashInfo.fType; }

isSimpleFill()

bool GrStyle::isSimpleFill ( ) const

inline

Is this style a fill with no path effect?

Definition at line 114 of file GrStyle.h.

{ return fStrokeRec.isFillStyle() && !fPathEffect; }

isSimpleHairline()

bool GrStyle::isSimpleHairline ( ) const

inline

Is this style a hairline with no path effect?

Definition at line 117 of file GrStyle.h.

{ return fStrokeRec.isHairlineStyle() && !fPathEffect; }

KeySize()

int GrStyle::KeySize ( const GrStyle &  style, Apply  apply, uint32_t  flags = 0  )

static

Computes the key length for a GrStyle. The return will be negative if it cannot be turned into a key. This occurs when there is a path effect that is not a dash. The key can either reflect just the path effect (if one) or the path effect and the strokerec. Note that a simple fill has a zero sized key.

Definition at line 11 of file GrStyle.cpp.

                                                                      {
    static_assert(sizeof(uint32_t) == sizeof(SkScalar));
    int size = 0;
    if (style.isDashed()) {
        // One scalar for scale, one for dash phase, and one for each dash value.
        size += 2 + style.dashIntervalCnt();
    } else if (style.pathEffect()) {
        // No key for a generic path effect.
        return -1;
    }
 
    if (Apply::kPathEffectOnly == apply) {
        return size;
    }
 
    if (style.strokeRec().needToApply()) {
        // One for res scale, one for style/cap/join, one for miter limit, and one for width.
        size += 4;
    }
    return size;
}

MatrixToScaleFactor()

static SkScalar GrStyle::MatrixToScaleFactor ( const SkMatrix &  matrix )

inlinestatic

Definition at line 147 of file GrStyle.h.

                                                                {
        // getMaxScale will return -1 if the matrix has perspective. In that case we can use a scale
        // factor of 1. This isn't necessarily a good choice and in the future we might consider
        // taking a bounds here for the perspective case.
        return SkScalarAbs(matrix.getMaxScale());
    }

operator=()

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

inline

Definition at line 96 of file GrStyle.h.

                                            {
        fPathEffect = that.fPathEffect;
        fDashInfo = that.fDashInfo;
        fStrokeRec = that.fStrokeRec;
        return *this;
    }

pathEffect()

SkPathEffect * GrStyle::pathEffect ( ) const

inline

Definition at line 119 of file GrStyle.h.

{ return fPathEffect.get(); }

refPathEffect()

sk_sp< SkPathEffect > GrStyle::refPathEffect ( ) const

inline

Definition at line 120 of file GrStyle.h.

{ return fPathEffect; }

resetToInitStyle()

void GrStyle::resetToInitStyle ( SkStrokeRec::InitStyle  fillOrHairline )

inline

Definition at line 103 of file GrStyle.h.

                                                               {
        fDashInfo.reset();
        fPathEffect.reset(nullptr);
        if (SkStrokeRec::kFill_InitStyle == fillOrHairline) {
            fStrokeRec.setFillStyle();
        } else {
            fStrokeRec.setHairlineStyle();
        }
    }

SimpleFill()

static const GrStyle & GrStyle::SimpleFill ( )

inlinestatic

A style object that represents a fill with no path effect. TODO: constexpr with C++14

Definition at line 30 of file GrStyle.h.

                                       {
        static const GrStyle kFill(SkStrokeRec::kFill_InitStyle);
        return kFill;
        }

SimpleHairline()

static const GrStyle & GrStyle::SimpleHairline ( )

inlinestatic

A style object that represents a hairline stroke with no path effect. TODO: constexpr with C++14

Definition at line 39 of file GrStyle.h.

                                           {
        static const GrStyle kHairline(SkStrokeRec::kHairline_InitStyle);
        return kHairline;
    }

strokeRec()

const SkStrokeRec & GrStyle::strokeRec ( ) const

inline

Definition at line 140 of file GrStyle.h.

{ return fStrokeRec; }

WriteKey()

void GrStyle::WriteKey ( uint32_t *  key, const GrStyle &  style, Apply  apply, SkScalar  scale, uint32_t  flags = 0  )

static

Writes a unique key for the style into the provided buffer. This function assumes the buffer has room for at least KeySize() values. It assumes that KeySize() returns a non-negative value for the combination of GrStyle, Apply and flags params. This is written so that the key for just dash application followed by the key for the remaining SkStrokeRec is the same as the key for applying dashing and SkStrokeRec all at once.

Definition at line 33 of file GrStyle.cpp.

                                       {
    SkASSERT(key);
    SkASSERT(KeySize(style, apply) >= 0);
    static_assert(sizeof(uint32_t) == sizeof(SkScalar));
 
    int i = 0;
    // The scale can influence both the path effect and stroking. We want to preserve the
    // property that the following two are equal:
    // 1. WriteKey with apply == kPathEffectAndStrokeRec
    // 2. WriteKey with apply == kPathEffectOnly followed by WriteKey of a GrStyle made
    //    from SkStrokeRec output by the the path effect (and no additional path effect).
    // Since the scale can affect both parts of 2 we write it into the key twice.
    if (style.isDashed()) {
        static_assert(sizeof(style.dashPhase()) == sizeof(uint32_t));
        SkScalar phase = style.dashPhase();
        memcpy(&key[i++], &scale, sizeof(SkScalar));
        memcpy(&key[i++], &phase, sizeof(SkScalar));
 
        int32_t count = style.dashIntervalCnt();
        // Dash count should always be even.
        SkASSERT(0 == (count & 0x1));
        const SkScalar *intervals = style.dashIntervals();
        int intervalByteCnt = count * sizeof(SkScalar);
        memcpy(&key[i], intervals, intervalByteCnt);
        i += count;
    } else {
        SkASSERT(!style.pathEffect());
    }
 
    if (Apply::kPathEffectAndStrokeRec == apply && style.strokeRec().needToApply()) {
        memcpy(&key[i++], &scale, sizeof(SkScalar));
        enum {
            kStyleBits = 2,
            kJoinBits = 2,
            kCapBits = 32 - kStyleBits - kJoinBits,
 
            kJoinShift = kStyleBits,
            kCapShift = kJoinShift + kJoinBits,
        };
        static_assert(SkStrokeRec::kStyleCount <= (1 << kStyleBits));
        static_assert(SkPaint::kJoinCount <= (1 << kJoinBits));
        static_assert(SkPaint::kCapCount <= (1 << kCapBits));
        // The cap type only matters for unclosed shapes. However, a path effect could unclose
        // the shape before it is stroked.
        SkPaint::Cap cap = SkPaint::kDefault_Cap;
        if (!(flags & kClosed_KeyFlag) || style.pathEffect()) {
            cap = style.strokeRec().getCap();
        }
        SkScalar miter = -1.f;
        SkPaint::Join join = SkPaint::kDefault_Join;
 
        // Dashing will not insert joins but other path effects may.
        if (!(flags & kNoJoins_KeyFlag) || style.hasNonDashPathEffect()) {
            join = style.strokeRec().getJoin();
            // Miter limit only affects miter joins
            if (SkPaint::kMiter_Join == join) {
                miter = style.strokeRec().getMiter();
            }
        }
 
        key[i++] = style.strokeRec().getStyle() |
                   join << kJoinShift |
                   cap << kCapShift;
 
        memcpy(&key[i++], &miter, sizeof(miter));
 
        SkScalar width = style.strokeRec().getWidth();
        memcpy(&key[i++], &width, sizeof(width));
    }
    SkASSERT(KeySize(style, apply) == i);
}

---

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

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