SkContourMeasureIter::Impl Class Reference

Public Member Functions
	Impl (const SkPath &path, bool forceClosed, SkScalar resScale)
bool	hasNextSegments () const
SkContourMeasure *	buildSegments ()

Detailed Description

Definition at line 187 of file SkContourMeasure.cpp.

Constructor & Destructor Documentation

Impl()

SkContourMeasureIter::Impl::Impl ( const SkPath &  path, bool  forceClosed, SkScalar  resScale  )

inline

Definition at line 189 of file SkContourMeasure.cpp.

        : fPath(path)
        , fIter(SkPathPriv::Iterate(fPath).begin())
        , fTolerance(CHEAP_DIST_LIMIT * sk_ieee_float_divide(1.0f, resScale))
        , fForceClosed(forceClosed) {}

Member Function Documentation

buildSegments()

SkContourMeasure * SkContourMeasureIter::Impl::buildSegments

(

)

Definition at line 356 of file SkContourMeasure.cpp.

                                                          {
    int         ptIndex = -1;
    SkScalar    distance = 0;
    bool        haveSeenClose = fForceClosed;
    bool        haveSeenMoveTo = false;
 
    /*  Note:
     *  as we accumulate distance, we have to check that the result of +=
     *  actually made it larger, since a very small delta might be > 0, but
     *  still have no effect on distance (if distance >>> delta).
     *
     *  We do this check below, and in compute_quad_segs and compute_cubic_segs
     */
 
    fSegments.reset();
    fPts.reset();
 
    auto end = SkPathPriv::Iterate(fPath).end();
    for (; fIter != end; ++fIter) {
        auto [verb, pts, w] = *fIter;
        if (haveSeenMoveTo && verb == SkPathVerb::kMove) {
            break;
        }
        switch (verb) {
            case SkPathVerb::kMove:
                ptIndex += 1;
                fPts.append(1, pts);
                SkASSERT(!haveSeenMoveTo);
                haveSeenMoveTo = true;
                break;
 
            case SkPathVerb::kLine: {
                SkASSERT(haveSeenMoveTo);
                SkScalar prevD = distance;
                distance = this->compute_line_seg(pts[0], pts[1], distance, ptIndex);
                if (distance > prevD) {
                    fPts.append(1, pts + 1);
                    ptIndex++;
                }
            } break;
 
            case SkPathVerb::kQuad: {
                SkASSERT(haveSeenMoveTo);
                SkScalar prevD = distance;
                distance = this->compute_quad_segs(pts, distance, 0, kMaxTValue, ptIndex);
                if (distance > prevD) {
                    fPts.append(2, pts + 1);
                    ptIndex += 2;
                }
            } break;
 
            case SkPathVerb::kConic: {
                SkASSERT(haveSeenMoveTo);
                const SkConic conic(pts, *w);
                SkScalar prevD = distance;
                distance = this->compute_conic_segs(conic, distance, 0, conic.fPts[0],
                                                    kMaxTValue, conic.fPts[2], ptIndex);
                if (distance > prevD) {
                    // we store the conic weight in our next point, followed by the last 2 pts
                    // thus to reconstitue a conic, you'd need to say
                    // SkConic(pts[0], pts[2], pts[3], weight = pts[1].fX)
                    fPts.append()->set(conic.fW, 0);
                    fPts.append(2, pts + 1);
                    ptIndex += 3;
                }
            } break;
 
            case SkPathVerb::kCubic: {
                SkASSERT(haveSeenMoveTo);
                SkScalar prevD = distance;
                distance = this->compute_cubic_segs(pts, distance, 0, kMaxTValue, ptIndex);
                if (distance > prevD) {
                    fPts.append(3, pts + 1);
                    ptIndex += 3;
                }
            } break;
 
            case SkPathVerb::kClose:
                haveSeenClose = true;
                break;
        }
 
    }
 
    if (!SkIsFinite(distance)) {
        return nullptr;
    }
    if (fSegments.empty()) {
        return nullptr;
    }
 
    if (haveSeenClose) {
        SkScalar prevD = distance;
        SkPoint firstPt = fPts[0];
        distance = this->compute_line_seg(fPts[ptIndex], firstPt, distance, ptIndex);
        if (distance > prevD) {
            *fPts.append() = firstPt;
        }
    }
 
    SkDEBUGCODE(this->validate();)
 
    return new SkContourMeasure(std::move(fSegments), std::move(fPts), distance, haveSeenClose);
}

hasNextSegments()

bool SkContourMeasureIter::Impl::hasNextSegments ( ) const

inline

Definition at line 195 of file SkContourMeasure.cpp.

{ return fIter != SkPathPriv::Iterate(fPath).end(); }

---

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

• third_party/skia/src/core/SkContourMeasure.cpp