SkPathPriv Class Reference

#include <SkPathPriv.h>

Classes
struct	Iterate
struct	Verbs

Public Types
using	RangeIter = SkPath::RangeIter

Static Public Member Functions
static SkPathFirstDirection	AsFirstDirection (SkPathDirection dir)
static SkPathFirstDirection	OppositeFirstDirection (SkPathFirstDirection dir)
static SkPathFirstDirection	ComputeFirstDirection (const SkPath &)
static bool	IsClosedSingleContour (const SkPath &path)
static int	LeadingMoveToCount (const SkPath &path)
static void	AddGenIDChangeListener (const SkPath &path, sk_sp< SkIDChangeListener > listener)
static bool	IsSimpleRect (const SkPath &path, bool isSimpleFill, SkRect *rect, SkPathDirection *direction, unsigned *start)
static void	CreateDrawArcPath (SkPath *path, const SkArc &arc, bool isFillNoPathEffect)
static bool	DrawArcIsConvex (SkScalar sweepAngle, SkArc::Type arcType, bool isFillNoPathEffect)
static void	ShrinkToFit (SkPath *path)
static const uint8_t *	VerbData (const SkPath &path)
static const SkPoint *	PointData (const SkPath &path)
static int	ConicWeightCnt (const SkPath &path)
static const SkScalar *	ConicWeightData (const SkPath &path)
static bool	TestingOnly_unique (const SkPath &path)
static bool	HasComputedBounds (const SkPath &path)
static bool	IsOval (const SkPath &path, SkRect *rect, SkPathDirection *dir, unsigned *start)
static bool	IsRRect (const SkPath &path, SkRRect *rrect, SkPathDirection *dir, unsigned *start)
static bool	TooBigForMath (const SkRect &bounds)
static bool	TooBigForMath (const SkPath &path)
static int	PtsInIter (unsigned verb)
static int	PtsInVerb (unsigned verb)
static bool	IsAxisAligned (const SkPath &path)
static bool	AllPointsEq (const SkPoint pts[], int count)
static int	LastMoveToIndex (const SkPath &path)
static bool	IsRectContour (const SkPath &, bool allowPartial, int *currVerb, const SkPoint **ptsPtr, bool *isClosed, SkPathDirection *direction, SkRect *rect)
static bool	IsNestedFillRects (const SkPath &, SkRect rect[2], SkPathDirection dirs[2]=nullptr)
static bool	IsInverseFillType (SkPathFillType fill)
static SkPathFillType	ConvertToNonInverseFillType (SkPathFillType fill)
static bool	PerspectiveClip (const SkPath &src, const SkMatrix &, SkPath *result)
static int	GenIDChangeListenersCount (const SkPath &)
static void	UpdatePathPoint (SkPath *path, int index, const SkPoint &pt)
static SkPathConvexity	GetConvexity (const SkPath &path)
static SkPathConvexity	GetConvexityOrUnknown (const SkPath &path)
static void	SetConvexity (const SkPath &path, SkPathConvexity c)
static void	ForceComputeConvexity (const SkPath &path)
static void	ReverseAddPath (SkPathBuilder *builder, const SkPath &reverseMe)
static SkPath	MakePath (const SkPathVerbAnalysis &analysis, const SkPoint points[], const uint8_t verbs[], int verbCount, const SkScalar conics[], SkPathFillType fillType, bool isVolatile)

Static Public Attributes
static constexpr SkScalar	kW0PlaneDistance = 1.f / (1 << 14)

Detailed Description

Definition at line 37 of file SkPathPriv.h.

Member Typedef Documentation

RangeIter

using SkPathPriv::RangeIter = SkPath::RangeIter

Iterates through a raw range of path verbs, points, and conics. All values are returned unaltered.

NOTE: This class's definition will be moved into SkPathPriv once RangeIter is removed.

Definition at line 164 of file SkPathPriv.h.

Member Function Documentation

AddGenIDChangeListener()

static void SkPathPriv::AddGenIDChangeListener ( const SkPath &  path, sk_sp< SkIDChangeListener >  listener  )

inlinestatic

Definition at line 106 of file SkPathPriv.h.

                                                                                               {
        path.fPathRef->addGenIDChangeListener(std::move(listener));
    }

AllPointsEq()

static bool SkPathPriv::AllPointsEq ( const SkPoint  pts[], int  count  )

inlinestatic

Definition at line 339 of file SkPathPriv.h.

                                                            {
        for (int i = 1; i < count; ++i) {
            if (pts[0] != pts[i]) {
                return false;
            }
        }
        return true;
    }

AsFirstDirection()

static SkPathFirstDirection SkPathPriv::AsFirstDirection ( SkPathDirection  dir )

inlinestatic

Definition at line 43 of file SkPathPriv.h.

                                                                      {
        // since we agree numerically for the values in Direction, we can just cast.
        return (SkPathFirstDirection)dir;
    }

ComputeFirstDirection()

SkPathFirstDirection SkPathPriv::ComputeFirstDirection ( const SkPath &  path )

static

Tries to compute the direction of the outer-most non-degenerate contour. If it can be computed, return that direction. If it cannot be determined, or the contour is known to be convex, return kUnknown. If the direction was determined, it is cached to make subsequent calls return quickly.

Definition at line 2627 of file SkPath.cpp.

                                                                         {
    auto d = path.getFirstDirection();
    if (d != SkPathFirstDirection::kUnknown) {
        return d;
    }
 
    // We don't want to pay the cost for computing convexity if it is unknown,
    // so we call getConvexityOrUnknown() instead of isConvex().
    if (path.getConvexityOrUnknown() == SkPathConvexity::kConvex) {
        SkASSERT(d == SkPathFirstDirection::kUnknown);
        return d;
    }
 
    ContourIter iter(*path.fPathRef);
 
    // initialize with our logical y-min
    SkScalar ymax = path.getBounds().fTop;
    SkScalar ymaxCross = 0;
 
    for (; !iter.done(); iter.next()) {
        int n = iter.count();
        if (n < 3) {
            continue;
        }
 
        const SkPoint* pts = iter.pts();
        SkScalar cross = 0;
        int index = find_max_y(pts, n);
        if (pts[index].fY < ymax) {
            continue;
        }
 
        // If there is more than 1 distinct point at the y-max, we take the
        // x-min and x-max of them and just subtract to compute the dir.
        if (pts[(index + 1) % n].fY == pts[index].fY) {
            int maxIndex;
            int minIndex = find_min_max_x_at_y(pts, index, n, &maxIndex);
            if (minIndex == maxIndex) {
                goto TRY_CROSSPROD;
            }
            SkASSERT(pts[minIndex].fY == pts[index].fY);
            SkASSERT(pts[maxIndex].fY == pts[index].fY);
            SkASSERT(pts[minIndex].fX <= pts[maxIndex].fX);
            // we just subtract the indices, and let that auto-convert to
            // SkScalar, since we just want - or + to signal the direction.
            cross = minIndex - maxIndex;
        } else {
            TRY_CROSSPROD:
            // Find a next and prev index to use for the cross-product test,
            // but we try to find pts that form non-zero vectors from pts[index]
            //
            // Its possible that we can't find two non-degenerate vectors, so
            // we have to guard our search (e.g. all the pts could be in the
            // same place).
 
            // we pass n - 1 instead of -1 so we don't foul up % operator by
            // passing it a negative LH argument.
            int prev = find_diff_pt(pts, index, n, n - 1);
            if (prev == index) {
                // completely degenerate, skip to next contour
                continue;
            }
            int next = find_diff_pt(pts, index, n, 1);
            SkASSERT(next != index);
            cross = cross_prod(pts[prev], pts[index], pts[next]);
            // if we get a zero and the points are horizontal, then we look at the spread in
            // x-direction. We really should continue to walk away from the degeneracy until
            // there is a divergence.
            if (0 == cross && pts[prev].fY == pts[index].fY && pts[next].fY == pts[index].fY) {
                // construct the subtract so we get the correct Direction below
                cross = pts[index].fX - pts[next].fX;
            }
        }
 
        if (cross) {
            // record our best guess so far
            ymax = pts[index].fY;
            ymaxCross = cross;
        }
    }
    if (ymaxCross) {
        d = crossToDir(ymaxCross);
        path.setFirstDirection(d);
    }
    return d;   // may still be kUnknown
}

ConicWeightCnt()

static int SkPathPriv::ConicWeightCnt ( const SkPath &  path )

inlinestatic

Returns the number of conic weights in the path

Definition at line 208 of file SkPathPriv.h.

                                                  {
        return path.fPathRef->countWeights();
    }

ConicWeightData()

static const SkScalar * SkPathPriv::ConicWeightData ( const SkPath &  path )

inlinestatic

Returns a raw pointer to the path conic weights.

Definition at line 213 of file SkPathPriv.h.

                                                               {
        return path.fPathRef->conicWeights();
    }

ConvertToNonInverseFillType()

static SkPathFillType SkPathPriv::ConvertToNonInverseFillType ( SkPathFillType  fill )

inlinestatic

Returns equivalent SkPath::FillType representing SkPath fill inside its bounds.

Parameters

fill	one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType, kInverseEvenOdd_FillType

Returns

fill, or kWinding_FillType or kEvenOdd_FillType if fill is inverted

Definition at line 379 of file SkPathPriv.h.

                                                                           {
        return (SkPathFillType)(static_cast<int>(fill) & 1);
    }

CreateDrawArcPath()

void SkPathPriv::CreateDrawArcPath ( SkPath *  path, const SkArc &  arc, bool  isFillNoPathEffect  )

static

Creates a path from arc params using the semantics of SkCanvas::drawArc. This function assumes empty ovals and zero sweeps have already been filtered out.

Definition at line 3356 of file SkPath.cpp.

                                                                                          {
    SkRect oval = arc.fOval;
    SkScalar startAngle = arc.fStartAngle, sweepAngle = arc.fSweepAngle;
    SkASSERT(!oval.isEmpty());
    SkASSERT(sweepAngle);
    // We cap the number of total rotations. This keeps the resulting paths simpler. More important,
    // it prevents values so large that the loops below never terminate (once ULP > 360).
    if (SkScalarAbs(sweepAngle) > 3600.0f) {
        sweepAngle = std::copysign(3600.0f, sweepAngle) + std::fmod(sweepAngle, 360.0f);
    }
    path->reset();
    path->setIsVolatile(true);
    path->setFillType(SkPathFillType::kWinding);
    if (isFillNoPathEffect && SkScalarAbs(sweepAngle) >= 360.f) {
        path->addOval(oval);
        SkASSERT(path->isConvex() &&
                 DrawArcIsConvex(sweepAngle, SkArc::Type::kArc, isFillNoPathEffect));
        return;
    }
    if (arc.isWedge()) {
        path->moveTo(oval.centerX(), oval.centerY());
    }
    auto firstDir =
            sweepAngle > 0 ? SkPathFirstDirection::kCW : SkPathFirstDirection::kCCW;
    bool convex = DrawArcIsConvex(sweepAngle, arc.fType, isFillNoPathEffect);
    // Arc to mods at 360 and drawArc is not supposed to.
    bool forceMoveTo = !arc.isWedge();
    while (sweepAngle <= -360.f) {
        path->arcTo(oval, startAngle, -180.f, forceMoveTo);
        startAngle -= 180.f;
        path->arcTo(oval, startAngle, -180.f, false);
        startAngle -= 180.f;
        forceMoveTo = false;
        sweepAngle += 360.f;
    }
    while (sweepAngle >= 360.f) {
        path->arcTo(oval, startAngle, 180.f, forceMoveTo);
        startAngle += 180.f;
        path->arcTo(oval, startAngle, 180.f, false);
        startAngle += 180.f;
        forceMoveTo = false;
        sweepAngle -= 360.f;
    }
    path->arcTo(oval, startAngle, sweepAngle, forceMoveTo);
    if (arc.isWedge()) {
        path->close();
    }
    path->setConvexity(convex ? SkPathConvexity::kConvex : SkPathConvexity::kConcave);
    path->setFirstDirection(firstDir);
}

DrawArcIsConvex()

bool SkPathPriv::DrawArcIsConvex ( SkScalar  sweepAngle, SkArc::Type  arcType, bool  isFillNoPathEffect  )

static

Determines whether an arc produced by CreateDrawArcPath will be convex. Assumes a non-empty oval.

Definition at line 3340 of file SkPath.cpp.

                                                          {
    if (isFillNoPathEffect && SkScalarAbs(sweepAngle) >= 360.f) {
        // This gets converted to an oval.
        return true;
    }
    if (arcType == SkArc::Type::kWedge) {
        // This is a pie wedge. It's convex if the angle is <= 180.
        return SkScalarAbs(sweepAngle) <= 180.f;
    }
    // When the angle exceeds 360 this wraps back on top of itself. Otherwise it is a circle clipped
    // to a secant, i.e. convex.
    return SkScalarAbs(sweepAngle) <= 360.f;
}

ForceComputeConvexity()

static void SkPathPriv::ForceComputeConvexity ( const SkPath &  path )

inlinestatic

Definition at line 416 of file SkPathPriv.h.

                                                          {
        path.setConvexity(SkPathConvexity::kUnknown);
        (void)path.isConvex();
    }

GenIDChangeListenersCount()

int SkPathPriv::GenIDChangeListenersCount ( const SkPath &  path )

static

Gets the number of GenIDChangeListeners. If another thread has access to this path then this may be stale before return and only indicates that the count was the return value at some point during the execution of the function.

Definition at line 3988 of file SkPath.cpp.

                                                            {
    return path.fPathRef->genIDChangeListenerCount();
}

GetConvexity()

static SkPathConvexity SkPathPriv::GetConvexity ( const SkPath &  path )

inlinestatic

Definition at line 407 of file SkPathPriv.h.

                                                            {
        return path.getConvexity();
    }

GetConvexityOrUnknown()

static SkPathConvexity SkPathPriv::GetConvexityOrUnknown ( const SkPath &  path )

inlinestatic

Definition at line 410 of file SkPathPriv.h.

                                                                     {
        return path.getConvexityOrUnknown();
    }

HasComputedBounds()

static bool SkPathPriv::HasComputedBounds ( const SkPath &  path )

inlinestatic

Definition at line 223 of file SkPathPriv.h.

                                                      {
        return path.hasComputedBounds();
    }

IsAxisAligned()

bool SkPathPriv::IsAxisAligned ( const SkPath &  path )

static

Definition at line 3992 of file SkPath.cpp.

                                                 {
    // Conservative (quick) test to see if all segments are axis-aligned.
    // Multiple contours might give a false-negative, but for speed, we ignore that
    // and just look at the raw points.
 
    const SkPoint* pts = path.fPathRef->points();
    const int count = path.fPathRef->countPoints();
 
    for (int i = 1; i < count; ++i) {
        if (pts[i-1].fX != pts[i].fX && pts[i-1].fY != pts[i].fY) {
            return false;
        }
    }
    return true;
}

IsClosedSingleContour()

static bool SkPathPriv::IsClosedSingleContour ( const SkPath &  path )

inlinestatic

Definition at line 67 of file SkPathPriv.h.

                                                          {
        int verbCount = path.countVerbs();
        if (verbCount == 0)
            return false;
        int moveCount = 0;
        auto verbs = path.fPathRef->verbsBegin();
        for (int i = 0; i < verbCount; i++) {
            switch (verbs[i]) {
                case SkPath::Verb::kMove_Verb:
                    moveCount += 1;
                    if (moveCount > 1) {
                        return false;
                    }
                    break;
                case SkPath::Verb::kClose_Verb:
                    if (i == verbCount - 1) {
                        return true;
                    }
                    return false;
                default: break;
            }
        }
        return false;
    }

IsInverseFillType()

static bool SkPathPriv::IsInverseFillType ( SkPathFillType  fill )

inlinestatic

Definition at line 368 of file SkPathPriv.h.

                                                       {
        return (static_cast<int>(fill) & 2) != 0;
    }

IsNestedFillRects()

bool SkPathPriv::IsNestedFillRects ( const SkPath &  path, SkRect  rect[2], SkPathDirection  dirs[2] = nullptr  )

static

Returns true if SkPath is equivalent to nested SkRect pair when filled. If false, rect and dirs are unchanged. If true, rect and dirs are written to if not nullptr: setting rect[0] to outer SkRect, and rect[1] to inner SkRect; setting dirs[0] to SkPathDirection of outer SkRect, and dirs[1] to SkPathDirection of inner SkRect.

Parameters

rect	storage for SkRect pair; may be nullptr
dirs	storage for SkPathDirection pair; may be nullptr

Returns

true if SkPath contains nested SkRect pair

Definition at line 3780 of file SkPath.cpp.

                                                                                               {
    SkDEBUGCODE(path.validate();)
    int currVerb = 0;
    const SkPoint* pts = path.fPathRef->points();
    SkPathDirection testDirs[2];
    SkRect testRects[2];
    if (!IsRectContour(path, true, &currVerb, &pts, nullptr, &testDirs[0], &testRects[0])) {
        return false;
    }
    if (IsRectContour(path, false, &currVerb, &pts, nullptr, &testDirs[1], &testRects[1])) {
        if (testRects[0].contains(testRects[1])) {
            if (rects) {
                rects[0] = testRects[0];
                rects[1] = testRects[1];
            }
            if (dirs) {
                dirs[0] = testDirs[0];
                dirs[1] = testDirs[1];
            }
            return true;
        }
        if (testRects[1].contains(testRects[0])) {
            if (rects) {
                rects[0] = testRects[1];
                rects[1] = testRects[0];
            }
            if (dirs) {
                dirs[0] = testDirs[1];
                dirs[1] = testDirs[0];
            }
            return true;
        }
    }
    return false;
}

IsOval()

static bool SkPathPriv::IsOval ( const SkPath &  path, SkRect *  rect, SkPathDirection *  dir, unsigned *  start  )

inlinestatic

Returns true if constructed by addCircle(), addOval(); and in some cases, addRoundRect(), addRRect(). SkPath constructed with conicTo() or rConicTo() will not return true though SkPath draws oval.

rect receives bounds of oval. dir receives SkPathDirection of oval: kCW_Direction if clockwise, kCCW_Direction if counterclockwise. start receives start of oval: 0 for top, 1 for right, 2 for bottom, 3 for left.

rect, dir, and start are unmodified if oval is not found.

Triggers performance optimizations on some GPU surface implementations.

Parameters

rect	storage for bounding SkRect of oval; may be nullptr
dir	storage for SkPathDirection; may be nullptr
start	storage for start of oval; may be nullptr

Returns

true if SkPath was constructed by method that reduces to oval

Definition at line 245 of file SkPathPriv.h.

                                                                                                {
        bool isCCW = false;
        bool result = path.fPathRef->isOval(rect, &isCCW, start);
        if (dir && result) {
            *dir = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
        }
        return result;
    }

IsRectContour()

bool SkPathPriv::IsRectContour ( const SkPath &  path, bool  allowPartial, int *  currVerb, const SkPoint **  ptsPtr, bool *  isClosed, SkPathDirection *  direction, SkRect *  rect  )

static

Definition at line 3639 of file SkPath.cpp.

                                             {
    int corners = 0;
    SkPoint closeXY;  // used to determine if final line falls on a diagonal
    SkPoint lineStart;  // used to construct line from previous point
    const SkPoint* firstPt = nullptr; // first point in the rect (last of first moves)
    const SkPoint* lastPt = nullptr;  // last point in the rect (last of lines or first if closed)
    SkPoint firstCorner;
    SkPoint thirdCorner;
    const SkPoint* pts = *ptsPtr;
    const SkPoint* savePts = nullptr; // used to allow caller to iterate through a pair of rects
    lineStart.set(0, 0);
    signed char directions[] = {-1, -1, -1, -1, -1};  // -1 to 3; -1 is uninitialized
    bool closedOrMoved = false;
    bool autoClose = false;
    bool insertClose = false;
    int verbCnt = path.fPathRef->countVerbs();
    while (*currVerb < verbCnt && (!allowPartial || !autoClose)) {
        uint8_t verb = insertClose ? (uint8_t) SkPath::kClose_Verb : path.fPathRef->atVerb(*currVerb);
        switch (verb) {
            case SkPath::kClose_Verb:
                savePts = pts;
                autoClose = true;
                insertClose = false;
                [[fallthrough]];
            case SkPath::kLine_Verb: {
                if (SkPath::kClose_Verb != verb) {
                    lastPt = pts;
                }
                SkPoint lineEnd = SkPath::kClose_Verb == verb ? *firstPt : *pts++;
                SkVector lineDelta = lineEnd - lineStart;
                if (lineDelta.fX && lineDelta.fY) {
                    return false; // diagonal
                }
                if (!lineDelta.isFinite()) {
                    return false; // path contains infinity or NaN
                }
                if (lineStart == lineEnd) {
                    break; // single point on side OK
                }
                int nextDirection = rect_make_dir(lineDelta.fX, lineDelta.fY); // 0 to 3
                if (0 == corners) {
                    directions[0] = nextDirection;
                    corners = 1;
                    closedOrMoved = false;
                    lineStart = lineEnd;
                    break;
                }
                if (closedOrMoved) {
                    return false; // closed followed by a line
                }
                if (autoClose && nextDirection == directions[0]) {
                    break; // colinear with first
                }
                closedOrMoved = autoClose;
                if (directions[corners - 1] == nextDirection) {
                    if (3 == corners && SkPath::kLine_Verb == verb) {
                        thirdCorner = lineEnd;
                    }
                    lineStart = lineEnd;
                    break; // colinear segment
                }
                directions[corners++] = nextDirection;
                // opposite lines must point in opposite directions; xoring them should equal 2
                switch (corners) {
                    case 2:
                        firstCorner = lineStart;
                        break;
                    case 3:
                        if ((directions[0] ^ directions[2]) != 2) {
                            return false;
                        }
                        thirdCorner = lineEnd;
                        break;
                    case 4:
                        if ((directions[1] ^ directions[3]) != 2) {
                            return false;
                        }
                        break;
                    default:
                        return false; // too many direction changes
                }
                lineStart = lineEnd;
                break;
            }
            case SkPath::kQuad_Verb:
            case SkPath::kConic_Verb:
            case SkPath::kCubic_Verb:
                return false; // quadratic, cubic not allowed
            case SkPath::kMove_Verb:
                if (allowPartial && !autoClose && directions[0] >= 0) {
                    insertClose = true;
                    *currVerb -= 1;  // try move again afterwards
                    goto addMissingClose;
                }
                if (!corners) {
                    firstPt = pts;
                } else {
                    closeXY = *firstPt - *lastPt;
                    if (closeXY.fX && closeXY.fY) {
                        return false;   // we're diagonal, abort
                    }
                }
                lineStart = *pts++;
                closedOrMoved = true;
                break;
            default:
                SkDEBUGFAIL("unexpected verb");
                break;
        }
        *currVerb += 1;
    addMissingClose:
        ;
    }
    // Success if 4 corners and first point equals last
    if (corners < 3 || corners > 4) {
        return false;
    }
    if (savePts) {
        *ptsPtr = savePts;
    }
    // check if close generates diagonal
    closeXY = *firstPt - *lastPt;
    if (closeXY.fX && closeXY.fY) {
        return false;
    }
    if (rect) {
        rect->set(firstCorner, thirdCorner);
    }
    if (isClosed) {
        *isClosed = autoClose;
    }
    if (direction) {
        *direction = directions[0] == ((directions[1] + 1) & 3) ?
                     SkPathDirection::kCW : SkPathDirection::kCCW;
    }
    return true;
}

IsRRect()

static bool SkPathPriv::IsRRect ( const SkPath &  path, SkRRect *  rrect, SkPathDirection *  dir, unsigned *  start  )

inlinestatic

Returns true if constructed by addRoundRect(), addRRect(); and if construction is not empty, not SkRect, and not oval. SkPath constructed with other calls will not return true though SkPath draws SkRRect.

rrect receives bounds of SkRRect. dir receives SkPathDirection of oval: kCW_Direction if clockwise, kCCW_Direction if counterclockwise. start receives start of SkRRect: 0 for top, 1 for right, 2 for bottom, 3 for left.

rrect, dir, and start are unmodified if SkRRect is not found.

Triggers performance optimizations on some GPU surface implementations.

Parameters

rrect	storage for bounding SkRect of SkRRect; may be nullptr
dir	storage for SkPathDirection; may be nullptr
start	storage for start of SkRRect; may be nullptr

Returns

true if SkPath contains only SkRRect

Definition at line 272 of file SkPathPriv.h.

                                         {
        bool isCCW = false;
        bool result = path.fPathRef->isRRect(rrect, &isCCW, start);
        if (dir && result) {
            *dir = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
        }
        return result;
    }

IsSimpleRect()

bool SkPathPriv::IsSimpleRect ( const SkPath &  path, bool  isSimpleFill, SkRect *  rect, SkPathDirection *  direction, unsigned *  start  )

static

This returns true for a rect that has a move followed by 3 or 4 lines and a close. If 'isSimpleFill' is true, an uncloseed rect will also be accepted as long as it starts and ends at the same corner. This does not permit degenerate line or point rectangles.

Definition at line 3244 of file SkPath.cpp.

                                                                           {
    if (path.getSegmentMasks() != SkPath::kLine_SegmentMask) {
        return false;
    }
    SkPoint rectPts[5];
    int rectPtCnt = 0;
    bool needsClose = !isSimpleFill;
    for (auto [v, verbPts, w] : SkPathPriv::Iterate(path)) {
        switch (v) {
            case SkPathVerb::kMove:
                if (0 != rectPtCnt) {
                    return false;
                }
                rectPts[0] = verbPts[0];
                ++rectPtCnt;
                break;
            case SkPathVerb::kLine:
                if (5 == rectPtCnt) {
                    return false;
                }
                rectPts[rectPtCnt] = verbPts[1];
                ++rectPtCnt;
                break;
            case SkPathVerb::kClose:
                if (4 == rectPtCnt) {
                    rectPts[4] = rectPts[0];
                    rectPtCnt = 5;
                }
                needsClose = false;
                break;
            case SkPathVerb::kQuad:
            case SkPathVerb::kConic:
            case SkPathVerb::kCubic:
                return false;
        }
    }
    if (needsClose) {
        return false;
    }
    if (rectPtCnt < 5) {
        return false;
    }
    if (rectPts[0] != rectPts[4]) {
        return false;
    }
    // Check for two cases of rectangles: pts 0 and 3 form a vertical edge or a horizontal edge (
    // and pts 1 and 2 the opposite vertical or horizontal edge).
    bool vec03IsVertical;
    if (rectPts[0].fX == rectPts[3].fX && rectPts[1].fX == rectPts[2].fX &&
        rectPts[0].fY == rectPts[1].fY && rectPts[3].fY == rectPts[2].fY) {
        // Make sure it has non-zero width and height
        if (rectPts[0].fX == rectPts[1].fX || rectPts[0].fY == rectPts[3].fY) {
            return false;
        }
        vec03IsVertical = true;
    } else if (rectPts[0].fY == rectPts[3].fY && rectPts[1].fY == rectPts[2].fY &&
               rectPts[0].fX == rectPts[1].fX && rectPts[3].fX == rectPts[2].fX) {
        // Make sure it has non-zero width and height
        if (rectPts[0].fY == rectPts[1].fY || rectPts[0].fX == rectPts[3].fX) {
            return false;
        }
        vec03IsVertical = false;
    } else {
        return false;
    }
    // Set sortFlags so that it has the low bit set if pt index 0 is on right edge and second bit
    // set if it is on the bottom edge.
    unsigned sortFlags =
            ((rectPts[0].fX < rectPts[2].fX) ? 0b00 : 0b01) |
            ((rectPts[0].fY < rectPts[2].fY) ? 0b00 : 0b10);
    switch (sortFlags) {
        case 0b00:
            rect->setLTRB(rectPts[0].fX, rectPts[0].fY, rectPts[2].fX, rectPts[2].fY);
            *direction = vec03IsVertical ? SkPathDirection::kCW : SkPathDirection::kCCW;
            *start = 0;
            break;
        case 0b01:
            rect->setLTRB(rectPts[2].fX, rectPts[0].fY, rectPts[0].fX, rectPts[2].fY);
            *direction = vec03IsVertical ? SkPathDirection::kCCW : SkPathDirection::kCW;
            *start = 1;
            break;
        case 0b10:
            rect->setLTRB(rectPts[0].fX, rectPts[2].fY, rectPts[2].fX, rectPts[0].fY);
            *direction = vec03IsVertical ? SkPathDirection::kCCW : SkPathDirection::kCW;
            *start = 3;
            break;
        case 0b11:
            rect->setLTRB(rectPts[2].fX, rectPts[2].fY, rectPts[0].fX, rectPts[0].fY);
            *direction = vec03IsVertical ? SkPathDirection::kCW : SkPathDirection::kCCW;
            *start = 2;
            break;
    }
    return true;
}

LastMoveToIndex()

static int SkPathPriv::LastMoveToIndex ( const SkPath &  path )

inlinestatic

Definition at line 348 of file SkPathPriv.h.

{ return path.fLastMoveToIndex; }

LeadingMoveToCount()

static int SkPathPriv::LeadingMoveToCount ( const SkPath &  path )

inlinestatic

Definition at line 95 of file SkPathPriv.h.

                                                      {
        int verbCount = path.countVerbs();
        auto verbs = path.fPathRef->verbsBegin();
        for (int i = 0; i < verbCount; i++) {
            if (verbs[i] != SkPath::Verb::kMove_Verb) {
                return i;
            }
        }
        return verbCount; // path is all move verbs
    }

MakePath()

static SkPath SkPathPriv::MakePath ( const SkPathVerbAnalysis &  analysis, const SkPoint  points[], const uint8_t  verbs[], int  verbCount, const SkScalar  conics[], SkPathFillType  fillType, bool  isVolatile  )

inlinestatic

Definition at line 425 of file SkPathPriv.h.

                                            {
        return SkPath::MakeInternal(analysis, points, verbs, verbCount, conics, fillType,
                                    isVolatile);
    }

OppositeFirstDirection()

static SkPathFirstDirection SkPathPriv::OppositeFirstDirection ( SkPathFirstDirection  dir )

inlinestatic

Return the opposite of the specified direction. kUnknown is its own opposite.

Definition at line 52 of file SkPathPriv.h.

                                                                                 {
        static const SkPathFirstDirection gOppositeDir[] = {
            SkPathFirstDirection::kCCW, SkPathFirstDirection::kCW, SkPathFirstDirection::kUnknown,
        };
        return gOppositeDir[(unsigned)dir];
    }

PerspectiveClip()

bool SkPathPriv::PerspectiveClip ( const SkPath &  src, const SkMatrix &  matrix, SkPath *  result  )

static

If needed (to not blow-up under a perspective matrix), clip the path, returning the answer in "result", and return true.

Note result might be empty (if the path was completely clipped out).

If no clipping is needed, returns false and "result" is left unchanged.

Definition at line 3962 of file SkPath.cpp.

                                                                                                {
    if (!matrix.hasPerspective()) {
        return false;
    }
 
    SkHalfPlane plane {
        matrix[SkMatrix::kMPersp0],
        matrix[SkMatrix::kMPersp1],
        matrix[SkMatrix::kMPersp2] - kW0PlaneDistance
    };
    if (plane.normalize()) {
        switch (plane.test(path.getBounds())) {
            case SkHalfPlane::kAllPositive:
                return false;
            case SkHalfPlane::kMixed: {
                *clippedPath = clip(path, plane);
                return true;
            }
            default: break; // handled outside of the switch
        }
    }
    // clipped out (or failed)
    *clippedPath = SkPath();
    return true;
}

PointData()

static const SkPoint * SkPathPriv::PointData ( const SkPath &  path )

inlinestatic

Returns a raw pointer to the path points

Definition at line 203 of file SkPathPriv.h.

                                                        {
        return path.fPathRef->points();
    }

PtsInIter()

static int SkPathPriv::PtsInIter ( unsigned  verb )

inlinestatic

Definition at line 305 of file SkPathPriv.h.

                                        {
        static const uint8_t gPtsInVerb[] = {
            1,  // kMove    pts[0]
            2,  // kLine    pts[0..1]
            3,  // kQuad    pts[0..2]
            3,  // kConic   pts[0..2]
            4,  // kCubic   pts[0..3]
            0,  // kClose
            0   // kDone
        };
 
        SkASSERT(verb < std::size(gPtsInVerb));
        return gPtsInVerb[verb];
    }

PtsInVerb()

static int SkPathPriv::PtsInVerb ( unsigned  verb )

inlinestatic

Definition at line 322 of file SkPathPriv.h.

                                        {
        static const uint8_t gPtsInVerb[] = {
            1,  // kMove    pts[0]
            1,  // kLine    pts[0..1]
            2,  // kQuad    pts[0..2]
            2,  // kConic   pts[0..2]
            3,  // kCubic   pts[0..3]
            0,  // kClose
            0   // kDone
        };
 
        SkASSERT(verb < std::size(gPtsInVerb));
        return gPtsInVerb[verb];
    }

ReverseAddPath()

static void SkPathPriv::ReverseAddPath ( SkPathBuilder *  builder, const SkPath &  reverseMe  )

inlinestatic

Definition at line 421 of file SkPathPriv.h.

                                                                                {
        builder->privateReverseAddPath(reverseMe);
    }

SetConvexity()

static void SkPathPriv::SetConvexity ( const SkPath &  path, SkPathConvexity  c  )

inlinestatic

Definition at line 413 of file SkPathPriv.h.

                                                                    {
        path.setConvexity(c);
    }

ShrinkToFit()

static void SkPathPriv::ShrinkToFit ( SkPath *  path )

inlinestatic

Definition at line 130 of file SkPathPriv.h.

                                          {
        path->shrinkToFit();
    }

TestingOnly_unique()

static bool SkPathPriv::TestingOnly_unique ( const SkPath &  path )

inlinestatic

Returns true if the underlying SkPathRef has one single owner.

Definition at line 218 of file SkPathPriv.h.

                                                       {
        return path.fPathRef->unique();
    }

TooBigForMath() [1/2]

static bool SkPathPriv::TooBigForMath ( const SkPath &  path )

inlinestatic

Definition at line 300 of file SkPathPriv.h.

                                                  {
        return TooBigForMath(path.getBounds());
    }

TooBigForMath() [2/2]

static bool SkPathPriv::TooBigForMath ( const SkRect &  bounds )

inlinestatic

Sometimes in the drawing pipeline, we have to perform math on path coordinates, even after the path is in device-coordinates. Tessellation and clipping are two examples. Usually this is pretty modest, but it can involve subtracting/adding coordinates, or multiplying by small constants (e.g. 2,3,4). To try to preflight issues where these optionations could turn finite path values into infinities (or NaNs), we allow the upper drawing code to reject the path if its bounds (in device coordinates) is too close to max float.

Definition at line 290 of file SkPathPriv.h.

                                                    {
        // This value is just a guess. smaller is safer, but we don't want to reject largish paths
        // that we don't have to.
        constexpr SkScalar scale_down_to_allow_for_small_multiplies = 0.25f;
        constexpr SkScalar max = SK_ScalarMax * scale_down_to_allow_for_small_multiplies;
 
        // use ! expression so we return true if bounds contains NaN
        return !(bounds.fLeft >= -max && bounds.fTop >= -max &&
                 bounds.fRight <= max && bounds.fBottom <= max);
    }

UpdatePathPoint()

static void SkPathPriv::UpdatePathPoint ( SkPath *  path, int  index, const SkPoint &  pt  )

inlinestatic

Definition at line 400 of file SkPathPriv.h.

                                                                            {
        SkASSERT(index < path->countPoints());
        SkPathRef::Editor ed(&path->fPathRef);
        ed.writablePoints()[index] = pt;
        path->dirtyAfterEdit();
    }

VerbData()

static const uint8_t * SkPathPriv::VerbData ( const SkPath &  path )

inlinestatic

Returns a pointer to the verb data.

Definition at line 198 of file SkPathPriv.h.

                                                       {
        return path.fPathRef->verbsBegin();
    }

Member Data Documentation

kW0PlaneDistance

constexpr SkScalar SkPathPriv::kW0PlaneDistance = 1.f / (1 << 14)

inlinestaticconstexpr

Definition at line 41 of file SkPathPriv.h.

---

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

• third_party/skia/src/core/SkPathPriv.h
• third_party/skia/src/core/SkPath.cpp