SkPathEdgeIter Class Reference

#include <SkPathPriv.h>

Classes
struct	Result

Public Types
enum class	Edge { kLine = SkPath::kLine_Verb , kQuad = SkPath::kQuad_Verb , kConic = SkPath::kConic_Verb , kCubic = SkPath::kCubic_Verb }

Public Member Functions
	SkPathEdgeIter (const SkPath &path)
SkScalar	conicWeight () const
Result	next ()

Static Public Member Functions
static SkPath::Verb	EdgeToVerb (Edge e)

Detailed Description

Definition at line 442 of file SkPathPriv.h.

Member Enumeration Documentation

Edge

enum class SkPathEdgeIter::Edge

strong

Enumerator
kLine
kQuad
kConic
kCubic

Definition at line 465 of file SkPathPriv.h.

                    {
        kLine  = SkPath::kLine_Verb,
        kQuad  = SkPath::kQuad_Verb,
        kConic = SkPath::kConic_Verb,
        kCubic = SkPath::kCubic_Verb,
    };

Constructor & Destructor Documentation

SkPathEdgeIter()

SkPathEdgeIter::SkPathEdgeIter

(

const SkPath &

path

)

Definition at line 4010 of file SkPath.cpp.

                                                 {
    fMoveToPtr = fPts = path.fPathRef->points();
    fVerbs = path.fPathRef->verbsBegin();
    fVerbsStop = path.fPathRef->verbsEnd();
    fConicWeights = path.fPathRef->conicWeights();
    if (fConicWeights) {
        fConicWeights -= 1;  // begin one behind
    }
 
    fNeedsCloseLine = false;
    fNextIsNewContour = false;
    SkDEBUGCODE(fIsConic = false;)
}

Member Function Documentation

conicWeight()

SkScalar SkPathEdgeIter::conicWeight ( ) const

inline

Definition at line 460 of file SkPathPriv.h.

                                 {
        SkASSERT(fIsConic);
        return *fConicWeights;
    }

EdgeToVerb()

static SkPath::Verb SkPathEdgeIter::EdgeToVerb ( Edge  e )

inlinestatic

Definition at line 472 of file SkPathPriv.h.

                                         {
        return SkPath::Verb(e);
    }

next()

Result SkPathEdgeIter::next ( )

inline

Definition at line 485 of file SkPathPriv.h.

                  {
        auto closeline = [&]() {
            fScratch[0] = fPts[-1];
            fScratch[1] = *fMoveToPtr;
            fNeedsCloseLine = false;
            fNextIsNewContour = true;
            return Result{ fScratch, Edge::kLine, false };
        };
 
        for (;;) {
            SkASSERT(fVerbs <= fVerbsStop);
            if (fVerbs == fVerbsStop) {
                return fNeedsCloseLine
                    ? closeline()
                    : Result{ nullptr, Edge(kIllegalEdgeValue), false };
            }
 
            SkDEBUGCODE(fIsConic = false;)
 
            const auto v = *fVerbs++;
            switch (v) {
                case SkPath::kMove_Verb: {
                    if (fNeedsCloseLine) {
                        auto res = closeline();
                        fMoveToPtr = fPts++;
                        return res;
                    }
                    fMoveToPtr = fPts++;
                    fNextIsNewContour = true;
                } break;
                case SkPath::kClose_Verb:
                    if (fNeedsCloseLine) return closeline();
                    break;
                default: {
                    // Actual edge.
                    const int pts_count = (v+2) / 2,
                              cws_count = (v & (v-1)) / 2;
                    SkASSERT(pts_count == SkPathPriv::PtsInIter(v) - 1);
 
                    fNeedsCloseLine = true;
                    fPts           += pts_count;
                    fConicWeights  += cws_count;
 
                    SkDEBUGCODE(fIsConic = (v == SkPath::kConic_Verb);)
                    SkASSERT(fIsConic == (cws_count > 0));
 
                    bool isNewContour = fNextIsNewContour;
                    fNextIsNewContour = false;
                    return { &fPts[-(pts_count + 1)], Edge(v), isNewContour };
                }
            }
        }
    }

---

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