skgpu::tess::StrokeIterator Class Reference

#include <StrokeIterator.h>

Public Types
enum class	Verb {   kLine = (int)SkPathVerb::kLine , kQuad = (int)SkPathVerb::kQuad , kConic = (int)SkPathVerb::kConic , kCubic = (int)SkPathVerb::kCubic ,   kCircle , kMoveWithinContour , kContourFinished }

Public Member Functions
	StrokeIterator (const SkPath &path, const SkStrokeRec *stroke, const SkMatrix *viewMatrix)
bool	next ()
Verb	prevVerb () const
const SkPoint *	prevPts () const
Verb	verb () const
const SkPoint *	pts () const
float	w () const
Verb	firstVerbInContour () const
const SkPoint *	firstPtsInContour () const

Static Public Member Functions
static constexpr bool	IsVerbGeometric (Verb verb)

Detailed Description

Definition at line 39 of file StrokeIterator.h.

Member Enumeration Documentation

Verb

enum class skgpu::tess::StrokeIterator::Verb

strong

Enumerator
kLine
kQuad
kConic
kCubic
kCircle
kMoveWithinContour
kContourFinished

Definition at line 48 of file StrokeIterator.h.

                    {
        // Verbs that describe stroke geometry.
        kLine = (int)SkPathVerb::kLine,
        kQuad = (int)SkPathVerb::kQuad,
        kConic = (int)SkPathVerb::kConic,
        kCubic = (int)SkPathVerb::kCubic,
        kCircle,  // A stroke-width circle drawn as a 180-degree point stroke.
 
        // Helper verbs that notify callers to update their own iteration state.
        kMoveWithinContour,
        kContourFinished
    };

Constructor & Destructor Documentation

StrokeIterator()

skgpu::tess::StrokeIterator::StrokeIterator ( const SkPath &  path, const SkStrokeRec *  stroke, const SkMatrix *  viewMatrix  )

inline

Definition at line 41 of file StrokeIterator.h.

            : fViewMatrix(viewMatrix), fStroke(stroke) {
        SkPathPriv::Iterate it(path);
        fIter = it.begin();
        fEnd = it.end();
    }

Member Function Documentation

firstPtsInContour()

const SkPoint * skgpu::tess::StrokeIterator::firstPtsInContour ( ) const

inline

Definition at line 138 of file StrokeIterator.h.

                                             {
        SkASSERT(fQueueCount > 0);
        return fFirstPtsInContour;
    }

firstVerbInContour()

Verb skgpu::tess::StrokeIterator::firstVerbInContour ( ) const

inline

Definition at line 137 of file StrokeIterator.h.

{ SkASSERT(fQueueCount > 0); return fFirstVerbInContour; }

IsVerbGeometric()

static constexpr bool skgpu::tess::StrokeIterator::IsVerbGeometric ( Verb  verb )

inlinestaticconstexpr

Definition at line 60 of file StrokeIterator.h.

{ return verb < Verb::kMoveWithinContour; }

next()

bool skgpu::tess::StrokeIterator::next ( )

inline

Definition at line 64 of file StrokeIterator.h.

                {
        if (fQueueCount) {
            SkASSERT(fQueueCount >= 2);
            this->popFront();
            if (fQueueCount >= 2) {
                return true;
            }
            SkASSERT(fQueueCount == 1);
            if (this->atVerb(0) == Verb::kContourFinished) {
                // Don't let "kContourFinished" be prevVerb at the start of the next contour.
                fQueueCount = 0;
            }
        }
        for (; fIter != fEnd; ++fIter) {
            SkASSERT(fQueueCount == 0 || fQueueCount == 1);
            auto [verb, pts, w] = *fIter;
            switch (verb) {
                case SkPathVerb::kMove:
                    if (!this->finishOpenContour()) {
                        continue;
                    }
                    break;
                case SkPathVerb::kCubic:
                    if (pts[3] == pts[2]) {
                        [[fallthrough]];  // i.e., "if (p3 == p2 && p2 == p1 && p1 == p0)"
                case SkPathVerb::kConic:
                case SkPathVerb::kQuad:
                    if (pts[2] == pts[1]) {
                        [[fallthrough]];  // i.e., "if (p2 == p1 && p1 == p0)"
                case SkPathVerb::kLine:
                    if (pts[1] == pts[0]) {
                        fLastDegenerateStrokePt = pts;
                        continue;
                    }}}
                    this->enqueue((Verb)verb, pts, w);
                    if (fQueueCount == 1) {
                        // Defer the first verb until the end when we know what it's joined to.
                        fFirstVerbInContour = (Verb)verb;
                        fFirstPtsInContour = pts;
                        fFirstWInContour = w;
                        continue;
                    }
                    break;
                case SkPathVerb::kClose:
                    if (!fQueueCount) {
                        fLastDegenerateStrokePt = pts;
                        continue;
                    }
                    if (pts[0] != fFirstPtsInContour[0]) {
                        // Draw a line back to the contour's starting point.
                        fClosePts = {pts[0], fFirstPtsInContour[0]};
                        this->enqueue(Verb::kLine, fClosePts.data(), nullptr);
                    }
                    // Repeat the first verb, this time as the "current" stroke instead of the prev.
                    this->enqueue(fFirstVerbInContour, fFirstPtsInContour, fFirstWInContour);
                    this->enqueue(Verb::kContourFinished, nullptr, nullptr);
                    fLastDegenerateStrokePt = nullptr;
                    break;
            }
            SkASSERT(fQueueCount >= 2);
            ++fIter;
            return true;
        }
        return this->finishOpenContour();
    }

prevPts()

const SkPoint * skgpu::tess::StrokeIterator::prevPts ( ) const

inline

Definition at line 131 of file StrokeIterator.h.

{ return this->atPts(0); }

prevVerb()

Verb skgpu::tess::StrokeIterator::prevVerb ( ) const

inline

Definition at line 130 of file StrokeIterator.h.

{ return this->atVerb(0); }

pts()

const SkPoint * skgpu::tess::StrokeIterator::pts ( ) const

inline

Definition at line 134 of file StrokeIterator.h.

{ return this->atPts(1); }

verb()

Verb skgpu::tess::StrokeIterator::verb ( ) const

inline

Definition at line 133 of file StrokeIterator.h.

{ return this->atVerb(1); }

w()

float skgpu::tess::StrokeIterator::w ( ) const

inline

Definition at line 135 of file StrokeIterator.h.

{ return this->atW(1); }

---

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

• third_party/skia/src/gpu/tessellate/StrokeIterator.h