GrStyledShape Class Reference

#include <GrStyledShape.h>

Public Types
enum class	DoSimplify : bool { kNo = false , kYes }
enum class	FillInversion { kPreserve , kFlip , kForceNoninverted , kForceInverted }

Public Member Functions
	GrStyledShape ()
	GrStyledShape (const SkPath &path, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRRect &rrect, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRect &rect, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkPath &path, const SkPaint &paint, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRRect &rrect, const SkPaint &paint, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRect &rect, const SkPaint &paint, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkPath &path, const GrStyle &style, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRRect &rrect, const GrStyle &style, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRRect &rrect, SkPathDirection dir, unsigned start, bool inverted, const GrStyle &style, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const SkRect &rect, const GrStyle &style, DoSimplify doSimplify=DoSimplify::kYes)
	GrStyledShape (const GrStyledShape &)
GrStyledShape &	operator= (const GrStyledShape &that)
const GrStyle &	style () const
bool	simplified () const
GrStyledShape	applyStyle (GrStyle::Apply apply, SkScalar scale) const
bool	isRect () const
bool	asRRect (SkRRect *rrect, bool *inverted) const
bool	asLine (SkPoint pts[2], bool *inverted) const
bool	asNestedRects (SkRect rects[2]) const
void	asPath (SkPath *out) const
bool	isEmpty () const
SkRect	bounds () const
SkRect	styledBounds () const
bool	knownToBeConvex () const
bool	knownDirection () const
bool	inverseFilled () const
bool	mayBeInverseFilledAfterStyling () const
bool	knownToBeClosed () const
uint32_t	segmentMask () const
int	unstyledKeySize () const
bool	hasUnstyledKey () const
void	writeUnstyledKey (uint32_t *key) const
void	addGenIDChangeListener (sk_sp< SkIDChangeListener >) const
uint32_t	testingOnly_getOriginalGenerationID () const
bool	testingOnly_isPath () const
bool	testingOnly_isNonVolatilePath () const
void	simplify ()

Static Public Member Functions
static GrStyledShape	MakeArc (const SkArc &arc, const GrStyle &style, DoSimplify=DoSimplify::kYes)
static GrStyledShape	MakeFilled (const GrStyledShape &original, FillInversion=FillInversion::kPreserve)

Static Public Attributes
static constexpr int	kMaxKeyFromDataVerbCnt = 10

Detailed Description

Represents a geometric shape (rrect or path) and the GrStyle that it should be rendered with. It is possible to apply the style to the GrStyledShape to produce a new GrStyledShape where the geometry reflects the styling information (e.g. is stroked). It is also possible to apply just the path effect from the style. In this case the resulting shape will include any remaining stroking information that is to be applied after the path effect.

Shapes can produce keys that represent only the geometry information, not the style. Note that when styling information is applied to produce a new shape then the style has been converted to geometric information and is included in the new shape's key. When the same style is applied to two shapes that reflect the same underlying geometry the computed keys of the stylized shapes will be the same.

Currently this can only be constructed from a path, rect, or rrect though it can become a path applying style to the geometry. The idea is to expand this to cover most or all of the geometries that have fast paths in the GPU backend.

Definition at line 49 of file GrStyledShape.h.

Member Enumeration Documentation

DoSimplify

enum class GrStyledShape::DoSimplify : bool

strong

Enumerator
kNo
kYes

Definition at line 57 of file GrStyledShape.h.

: bool { kNo = false, kYes };

FillInversion

enum class GrStyledShape::FillInversion

strong

Informs MakeFilled on how to modify that shape's fill rule when making a simple filled version of the shape.

Enumerator
kPreserve
kFlip
kForceNoninverted
kForceInverted

Definition at line 124 of file GrStyledShape.h.

                             {
        kPreserve,
        kFlip,
        kForceNoninverted,
        kForceInverted
    };

Constructor & Destructor Documentation

GrStyledShape() [1/12]

GrStyledShape::GrStyledShape ( )

inline

Definition at line 55 of file GrStyledShape.h.

{}

GrStyledShape() [2/12]

GrStyledShape::GrStyledShape ( const SkPath &  path, DoSimplify  doSimplify = DoSimplify::kYes  )

inlineexplicit

Definition at line 59 of file GrStyledShape.h.

            : GrStyledShape(path, GrStyle::SimpleFill(), doSimplify) {}

GrStyledShape() [3/12]

GrStyledShape::GrStyledShape ( const SkRRect &  rrect, DoSimplify  doSimplify = DoSimplify::kYes  )

inlineexplicit

Definition at line 62 of file GrStyledShape.h.

            : GrStyledShape(rrect, GrStyle::SimpleFill(), doSimplify) {}

GrStyledShape() [4/12]

GrStyledShape::GrStyledShape ( const SkRect &  rect, DoSimplify  doSimplify = DoSimplify::kYes  )

inlineexplicit

Definition at line 65 of file GrStyledShape.h.

            : GrStyledShape(rect, GrStyle::SimpleFill(), doSimplify) {}

GrStyledShape() [5/12]

GrStyledShape::GrStyledShape ( const SkPath &  path, const SkPaint &  paint, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 68 of file GrStyledShape.h.

            : GrStyledShape(path, GrStyle(paint), doSimplify) {}

GrStyledShape() [6/12]

GrStyledShape::GrStyledShape ( const SkRRect &  rrect, const SkPaint &  paint, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 72 of file GrStyledShape.h.

            : GrStyledShape(rrect, GrStyle(paint), doSimplify) {}

GrStyledShape() [7/12]

GrStyledShape::GrStyledShape ( const SkRect &  rect, const SkPaint &  paint, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 76 of file GrStyledShape.h.

            : GrStyledShape(rect, GrStyle(paint), doSimplify) {}

GrStyledShape() [8/12]

GrStyledShape::GrStyledShape ( const SkPath &  path, const GrStyle &  style, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 80 of file GrStyledShape.h.

            : fShape(path), fStyle(style) {
        if (doSimplify == DoSimplify::kYes) {
            this->simplify();
        }
    }

GrStyledShape() [9/12]

GrStyledShape::GrStyledShape ( const SkRRect &  rrect, const GrStyle &  style, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 88 of file GrStyledShape.h.

            : GrStyledShape(rrect, SkPathDirection::kCW, 6, false, style, doSimplify) {}

GrStyledShape() [10/12]

GrStyledShape::GrStyledShape ( const SkRRect &  rrect, SkPathDirection  dir, unsigned  start, bool  inverted, const GrStyle &  style, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 93 of file GrStyledShape.h.

            : fShape(rrect)
            , fStyle(style) {
        fShape.setPathWindingParams(dir, start);
        fShape.setInverted(inverted);
        if (doSimplify == DoSimplify::kYes) {
            this->simplify();
        }
    }

GrStyledShape() [11/12]

GrStyledShape::GrStyledShape ( const SkRect &  rect, const GrStyle &  style, DoSimplify  doSimplify = DoSimplify::kYes  )

inline

Definition at line 104 of file GrStyledShape.h.

            : fShape(rect), fStyle(style) {
        if (doSimplify == DoSimplify::kYes) {
            this->simplify();
        }
    }

GrStyledShape() [12/12]

GrStyledShape::GrStyledShape

(

const GrStyledShape &

that

)

Definition at line 330 of file GrStyledShape.cpp.

        : fShape(that.fShape)
        , fStyle(that.fStyle)
        , fGenID(that.fGenID)
        , fSimplified(that.fSimplified) {
    fInheritedKey.reset(that.fInheritedKey.count());
    sk_careful_memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
                      sizeof(uint32_t) * fInheritedKey.count());
    if (that.fInheritedPathForListeners.isValid()) {
        fInheritedPathForListeners.set(*that.fInheritedPathForListeners);
    }
}

Member Function Documentation

addGenIDChangeListener()

void GrStyledShape::addGenIDChangeListener

(

sk_sp< SkIDChangeListener >

listener

)

const

Adds a listener to the original path. Typically used to invalidate cached resources when a path is no longer in-use. If the shape started out as something other than a path, this does nothing.

Definition at line 311 of file GrStyledShape.cpp.

                                                                                   {
    if (const auto* lp = this->originalPathForListeners()) {
        SkPathPriv::AddGenIDChangeListener(*lp, std::move(listener));
    }
}

applyStyle()

GrStyledShape GrStyledShape::applyStyle ( GrStyle::Apply  apply, SkScalar  scale  ) const

inline

Returns a shape that has either applied the path effect or path effect and stroking information from this shape's style to its geometry. Scale is used when approximating the output geometry and typically is computed from the view matrix

Definition at line 150 of file GrStyledShape.h.

                                                                       {
        return GrStyledShape(*this, apply, scale);
    }

asLine()

bool GrStyledShape::asLine	(	SkPoint	pts[2],
		bool *	inverted
	)		const

If the unstyled shape is a straight line segment, returns true and sets pts to the endpoints. An inverse filled line path is still considered a line.

Definition at line 453 of file GrStyledShape.cpp.

                                                               {
    if (!fShape.isLine()) {
        return false;
    }
 
    if (pts) {
        pts[0] = fShape.line().fP1;
        pts[1] = fShape.line().fP2;
    }
    if (inverted) {
        *inverted = fShape.inverted();
    }
    return true;
}

asNestedRects()

bool GrStyledShape::asNestedRects

(

SkRect

rects[2]

)

const

Definition at line 468 of file GrStyledShape.cpp.

                                                       {
    if (!fShape.isPath()) {
        return false;
    }
 
    // TODO: it would be better two store DRRects natively in the shape rather than converting
    // them to a path and then reextracting the nested rects
    if (fShape.path().isInverseFillType()) {
        return false;
    }
 
    SkPathDirection dirs[2];
    if (!SkPathPriv::IsNestedFillRects(fShape.path(), rects, dirs)) {
        return false;
    }
 
    if (SkPathFillType::kWinding == fShape.path().getFillType() && dirs[0] == dirs[1]) {
        // The two rects need to be wound opposite to each other
        return false;
    }
 
    // Right now, nested rects where the margin is not the same width
    // all around do not render correctly
    const SkScalar* outer = rects[0].asScalars();
    const SkScalar* inner = rects[1].asScalars();
 
    bool allEq = true;
 
    SkScalar margin = SkScalarAbs(outer[0] - inner[0]);
    bool allGoE1 = margin >= SK_Scalar1;
 
    for (int i = 1; i < 4; ++i) {
        SkScalar temp = SkScalarAbs(outer[i] - inner[i]);
        if (temp < SK_Scalar1) {
            allGoE1 = false;
        }
        if (!SkScalarNearlyEqual(margin, temp)) {
            allEq = false;
        }
    }
 
    return allEq || allGoE1;
}

asPath()

void GrStyledShape::asPath ( SkPath *  out ) const

inline

Returns the unstyled geometry as a path.

Definition at line 173 of file GrStyledShape.h.

                                   {
        fShape.asPath(out, fStyle.isSimpleFill());
    }

asRRect()

bool GrStyledShape::asRRect	(	SkRRect *	rrect,
		bool *	inverted
	)		const

Returns the unstyled geometry as a rrect if possible.

Definition at line 437 of file GrStyledShape.cpp.

                                                                {
    if (!fShape.isRRect() && !fShape.isRect()) {
        return false;
    }
 
    if (rrect) {
        *rrect = fShape.isRect() ? SkRRect::MakeRect(fShape.rect()) : fShape.rrect();
    }
 
    if (inverted) {
        *inverted = fShape.inverted();
    }
 
    return true;
}

bounds()

SkRect GrStyledShape::bounds ( ) const

inline

Gets the bounds of the geometry without reflecting the shape's styling. This ignores the inverse fill nature of the geometry.

Definition at line 187 of file GrStyledShape.h.

{ return fShape.bounds(); }

hasUnstyledKey()

bool GrStyledShape::hasUnstyledKey ( ) const

inline

Definition at line 259 of file GrStyledShape.h.

{ return this->unstyledKeySize() >= 0; }

inverseFilled()

bool GrStyledShape::inverseFilled ( ) const

inline

Is the pre-styled geometry inverse filled?

Definition at line 217 of file GrStyledShape.h.

                               {
        // Since the path tracks inverted-fillness itself, it should match what was recorded.
        SkASSERT(!fShape.isPath() || fShape.inverted() == fShape.path().isInverseFillType());
        // Dashing ignores inverseness. We should have caught this earlier. skbug.com/5421
        SkASSERT(!(fShape.inverted() && this->style().isDashed()));
        return fShape.inverted();
    }

isEmpty()

bool GrStyledShape::isEmpty ( ) const

inline

Returns whether the geometry is empty. Note that applying the style could produce a non-empty shape. It also may have an inverse fill.

Definition at line 181 of file GrStyledShape.h.

{ return fShape.isEmpty(); }

isRect()

bool GrStyledShape::isRect ( ) const

inline

Definition at line 154 of file GrStyledShape.h.

                        {
        // Should have simplified a rrect to a rect if possible already.
        SkASSERT(!fShape.isRRect() || !fShape.rrect().isRect());
        return fShape.isRect();
    }

knownDirection()

bool GrStyledShape::knownDirection ( ) const

inline

Does the shape have a known winding direction. Some degenerate convex shapes may not have a computable direction, but this is not always a requirement for path renderers so it is kept separate from knownToBeConvex().

Definition at line 209 of file GrStyledShape.h.

                                {
        // Assuming this is called after knownToBeConvex(), this should just be relying on
        // cached convexity and direction and will be cheap.
        return !fShape.isPath() ||
               SkPathPriv::ComputeFirstDirection(fShape.path()) != SkPathFirstDirection::kUnknown;
    }

knownToBeClosed()

bool GrStyledShape::knownToBeClosed ( ) const

inline

Is it known that the unstyled geometry has no unclosed contours. This means that it will not have any caps if stroked (modulo the effect of any path effect).

Definition at line 243 of file GrStyledShape.h.

                                 {
        // This refers to the base shape and does not depend on invertedness.
        return fShape.closed();
    }

knownToBeConvex()

bool GrStyledShape::knownToBeConvex ( ) const

inline

Is this shape known to be convex, before styling is applied. An unclosed but otherwise convex path is considered to be closed if they styling reflects a fill and not otherwise. This is because filling closes all contours in the path.

Definition at line 200 of file GrStyledShape.h.

                                 {
        return fShape.convex(fStyle.isSimpleFill());
    }

MakeArc()

GrStyledShape GrStyledShape::MakeArc ( const SkArc &  arc, const GrStyle &  style, DoSimplify  doSimplify = DoSimplify::kYes  )

static

Definition at line 317 of file GrStyledShape.cpp.

                                                            {
    GrStyledShape result;
    result.fShape.setArc(
            SkArc::Make(arc.fOval.makeSorted(), arc.fStartAngle, arc.fSweepAngle, arc.fType));
    result.fStyle = style;
    if (doSimplify == DoSimplify::kYes) {
        result.simplify();
    }
    return result;
}

MakeFilled()

GrStyledShape GrStyledShape::MakeFilled ( const GrStyledShape &  original, FillInversion  inversion = FillInversion::kPreserve  )

static

Makes a filled shape from the pre-styled original shape and optionally modifies whether the fill is inverted or not. It's important to note that the original shape's geometry may already have been modified if doing so was neutral with respect to its style (e.g. filled paths are always closed when stored in a shape and dashed paths are always made non-inverted since dashing ignores inverseness).

Definition at line 56 of file GrStyledShape.cpp.

                                                                                              {
    bool newIsInverted = is_inverted(original.fShape.inverted(), inversion);
    if (original.style().isSimpleFill() && newIsInverted == original.fShape.inverted()) {
        // By returning the original rather than falling through we can preserve any inherited style
        // key. Otherwise, we wipe it out below since the style change invalidates it.
        return original;
    }
    GrStyledShape result;
    SkASSERT(result.fStyle.isSimpleFill());
    if (original.fInheritedPathForListeners.isValid()) {
        result.fInheritedPathForListeners.set(*original.fInheritedPathForListeners);
    }
 
    result.fShape = original.fShape;
    result.fGenID = original.fGenID;
    result.fShape.setInverted(newIsInverted);
 
    if (!original.style().isSimpleFill()) {
        // Going from a non-filled style to fill may allow additional simplifications (e.g.
        // closing an open rect that wasn't closed in the original shape because it had
        // stroke style).
        result.simplify();
        // The above simplify() call only sets simplified to true if its geometry was changed,
        // since it already sees its style as a simple fill. Since the original style was not a
        // simple fill, MakeFilled always simplifies.
        result.fSimplified = true;
    }
 
    // Verify that lines/points were converted to empty by the style change
    SkASSERT((!original.fShape.isLine() && !original.fShape.isPoint()) || result.fShape.isEmpty());
 
    // We don't copy the inherited key since it can contain path effect information that we just
    // stripped.
    return result;
}

mayBeInverseFilledAfterStyling()

bool GrStyledShape::mayBeInverseFilledAfterStyling ( ) const

inline

Might applying the styling to the geometry produce an inverse fill. The "may" part comes in because an arbitrary path effect could produce an inverse filled path. In other cases this can be thought of as "inverseFilledAfterStyling()".

Definition at line 230 of file GrStyledShape.h.

                                                {
         // An arbitrary path effect can produce an arbitrary output path, which may be inverse
         // filled.
        if (this->style().hasNonDashPathEffect()) {
            return true;
        }
        return this->inverseFilled();
    }

operator=()

GrStyledShape & GrStyledShape::operator=

(

const GrStyledShape &

that

)

Definition at line 25 of file GrStyledShape.cpp.

                                                                 {
    fShape      = that.fShape;
    fStyle      = that.fStyle;
    fGenID      = that.fGenID;
    fSimplified = that.fSimplified;
 
    fInheritedKey.reset(that.fInheritedKey.count());
    sk_careful_memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
                      sizeof(uint32_t) * fInheritedKey.count());
    if (that.fInheritedPathForListeners.isValid()) {
        fInheritedPathForListeners.set(*that.fInheritedPathForListeners);
    } else {
        fInheritedPathForListeners.reset();
    }
    return *this;
}

segmentMask()

uint32_t GrStyledShape::segmentMask ( ) const

inline

Definition at line 248 of file GrStyledShape.h.

                                 {
        // This refers to the base shape and does not depend on invertedness.
        return fShape.segmentMask();
    }

simplified()

bool GrStyledShape::simplified ( ) const

inline

Definition at line 143 of file GrStyledShape.h.

{ return fSimplified; }

simplify()

void GrStyledShape::simplify

(

)

Similar to GrShape::simplify but also takes into account style and stroking, possibly applying the style explicitly to produce a new analytic shape with a simpler style. Unless "doSimplify" is kNo, this method gets called automatically during construction.

Definition at line 529 of file GrStyledShape.cpp.

                             {
    AutoRestoreInverseness ari(&fShape, fStyle);
 
    unsigned simplifyFlags = 0;
    if (fStyle.isSimpleFill()) {
        simplifyFlags = GrShape::kAll_Flags;
    } else if (!fStyle.hasPathEffect()) {
        // Everything but arcs with caps that might extend beyond the oval edge can ignore winding
        if (!fShape.isArc() || fStyle.strokeRec().getCap() == SkPaint::kButt_Cap) {
            simplifyFlags |= GrShape::kIgnoreWinding_Flag;
        }
        simplifyFlags |= GrShape::kMakeCanonical_Flag;
    } // else if there's a path effect, every destructive simplification is disabledd
 
    // Remember if the original shape was closed; in the event we simplify to a point or line
    // because of degenerate geometry, we need to update joins and caps.
    GrShape::Type oldType = fShape.type();
    fClosed = fShape.simplify(simplifyFlags);
    fSimplified = oldType != fShape.type();
 
    if (fShape.isPath()) {
        // The shape remains a path, so configure the gen ID and canonicalize fill type if possible
        if (fInheritedKey.count() || fShape.path().isVolatile()) {
            fGenID = 0;
        } else {
            fGenID = fShape.path().getGenerationID();
        }
        if (!fStyle.hasNonDashPathEffect() &&
            (fStyle.strokeRec().getStyle() == SkStrokeRec::kStroke_Style ||
             fStyle.strokeRec().getStyle() == SkStrokeRec::kHairline_Style ||
             fShape.path().isConvex())) {
            // Stroke styles don't differentiate between winding and even/odd. There is no
            // distinction between even/odd and non-zero winding count for convex paths.
            // Moreover, dashing ignores inverseness (skbug.com/5421)
            fShape.path().setFillType(GrShape::kDefaultFillType);
        }
    } else {
        fInheritedKey.reset(0);
        // Whenever we simplify to a non-path, break the chain so we no longer refer to the
        // original path. This prevents attaching genID listeners to temporary paths created when
        // drawing simple shapes.
        fInheritedPathForListeners.reset();
        // Further simplifications to the shape based on the style
        this->simplifyStroke();
    }
}

style()

const GrStyle & GrStyledShape::style ( ) const

inline

Definition at line 140 of file GrStyledShape.h.

{ return fStyle; }

styledBounds()

SkRect GrStyledShape::styledBounds

(

)

const

Gets the bounds of the geometry reflecting the shape's styling (ignoring inverse fill status).

Definition at line 92 of file GrStyledShape.cpp.

                                         {
    if (this->isEmpty() && !fStyle.hasNonDashPathEffect()) {
        return SkRect::MakeEmpty();
    }
 
    SkRect bounds;
    fStyle.adjustBounds(&bounds, this->bounds());
    return bounds;
}

testingOnly_getOriginalGenerationID()

uint32_t GrStyledShape::testingOnly_getOriginalGenerationID

(

)

const

Helpers that are only exposed for unit tests, to determine if the shape is a path, and get the generation ID of the original path. This is the path that will receive GenIDChangeListeners added to this shape.

Definition at line 50 of file GrStyledShapeTest.cpp.

                                                                  {
    if (const auto* lp = this->originalPathForListeners()) {
        return lp->getGenerationID();
    }
    return SkPath().getGenerationID();
}

testingOnly_isNonVolatilePath()

bool GrStyledShape::testingOnly_isNonVolatilePath

(

)

const

Definition at line 61 of file GrStyledShapeTest.cpp.

                                                        {
    return fShape.isPath() && !fShape.path().isVolatile();
}

testingOnly_isPath()

bool GrStyledShape::testingOnly_isPath

(

)

const

Definition at line 57 of file GrStyledShapeTest.cpp.

                                             {
    return fShape.isPath();
}

unstyledKeySize()

int GrStyledShape::unstyledKeySize

(

)

const

Gets the size of the key for the shape represented by this GrStyledShape (ignoring its styling). A negative value is returned if the shape has no key (shouldn't be cached).

Definition at line 144 of file GrStyledShape.cpp.

                                         {
    if (fInheritedKey.count()) {
        return fInheritedKey.count();
    }
 
    int count = 1; // Every key has the state flags from the GrShape
    switch(fShape.type()) {
        case GrShape::Type::kPoint:
            static_assert(0 == sizeof(SkPoint) % sizeof(uint32_t));
            count += sizeof(SkPoint) / sizeof(uint32_t);
            break;
        case GrShape::Type::kRect:
            static_assert(0 == sizeof(SkRect) % sizeof(uint32_t));
            count += sizeof(SkRect) / sizeof(uint32_t);
            break;
        case GrShape::Type::kRRect:
            static_assert(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
            count += SkRRect::kSizeInMemory / sizeof(uint32_t);
            break;
        case GrShape::Type::kArc:
            static_assert(0 == sizeof(SkArc) % sizeof(uint32_t));
            count += sizeof(SkArc) / sizeof(uint32_t);
            break;
        case GrShape::Type::kLine:
            static_assert(0 == sizeof(GrLineSegment) % sizeof(uint32_t));
            count += sizeof(GrLineSegment) / sizeof(uint32_t);
            break;
        case GrShape::Type::kPath: {
            if (0 == fGenID) {
                return -1; // volatile, so won't be keyed
            }
            int dataKeySize = path_key_from_data_size(fShape.path());
            if (dataKeySize >= 0) {
                count += dataKeySize;
            } else {
                count++; // Just adds the gen ID.
            }
            break; }
        default:
            // else it's empty, which just needs the state flags for its key
            SkASSERT(fShape.isEmpty());
    }
    return count;
}

writeUnstyledKey()

void GrStyledShape::writeUnstyledKey

(

uint32_t *

key

)

const

Writes unstyledKeySize() bytes into the provided pointer. Assumes that there is enough space allocated for the key and that unstyledKeySize() does not return a negative value for this shape.

Definition at line 189 of file GrStyledShape.cpp.

                                                        {
    SkASSERT(this->unstyledKeySize());
    SkDEBUGCODE(uint32_t* origKey = key;)
    if (fInheritedKey.count()) {
        memcpy(key, fInheritedKey.get(), sizeof(uint32_t) * fInheritedKey.count());
        SkDEBUGCODE(key += fInheritedKey.count();)
    } else {
        // Dir and start are only used for rect and rrect shapes, so are not included in other
        // shape type keys. Make sure that they are the defaults for other shapes so it doesn't
        // matter that we universally include them in the flag key value.
        SkASSERT((fShape.isRect() || fShape.isRRect()) ||
                 (fShape.dir() == GrShape::kDefaultDir &&
                  fShape.startIndex() == GrShape::kDefaultStart));
 
        // Every key starts with the state from the GrShape (this includes path fill type,
        // and any tracked winding, start, inversion, as well as the class of geometry).
        *key++ = fShape.stateKey();
 
        switch(fShape.type()) {
            case GrShape::Type::kPath: {
                SkASSERT(fGenID != 0);
                // Ensure that the path's inversion matches our state so that the path's key suffices.
                SkASSERT(fShape.inverted() == fShape.path().isInverseFillType());
 
                int dataKeySize = path_key_from_data_size(fShape.path());
                if (dataKeySize >= 0) {
                    write_path_key_from_data(fShape.path(), key);
                    return;
                } else {
                    *key++ = fGenID;
                }
                break; }
            case GrShape::Type::kPoint:
                memcpy(key, &fShape.point(), sizeof(SkPoint));
                key += sizeof(SkPoint) / sizeof(uint32_t);
                break;
            case GrShape::Type::kRect:
                memcpy(key, &fShape.rect(), sizeof(SkRect));
                key += sizeof(SkRect) / sizeof(uint32_t);
                break;
            case GrShape::Type::kRRect:
                fShape.rrect().writeToMemory(key);
                key += SkRRect::kSizeInMemory / sizeof(uint32_t);
                break;
            case GrShape::Type::kArc:
                // Write dense floats first
                memcpy(key, &fShape.arc(), sizeof(SkRect) + 2 * sizeof(float));
                key += (sizeof(SkArc) / sizeof(uint32_t) - 1);
                // Then write the final bool as an int, to make sure upper bits are set
                *key++ = fShape.arc().isWedge() ? 1 : 0;
                break;
            case GrShape::Type::kLine:
                memcpy(key, &fShape.line(), sizeof(GrLineSegment));
                key += sizeof(GrLineSegment) / sizeof(uint32_t);
                break;
            default:
                // Nothing other than the flag state is needed in the key for an empty shape
                SkASSERT(fShape.isEmpty());
        }
    }
    SkASSERT(key - origKey == this->unstyledKeySize());
}

Member Data Documentation

kMaxKeyFromDataVerbCnt

constexpr int GrStyledShape::kMaxKeyFromDataVerbCnt = 10

inlinestaticconstexpr

Definition at line 53 of file GrStyledShape.h.

---

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

• third_party/skia/src/gpu/ganesh/geometry/GrStyledShape.h
• third_party/skia/src/gpu/ganesh/geometry/GrStyledShape.cpp
• third_party/skia/tests/GrStyledShapeTest.cpp