SkEdgeClipper Class Reference

#include <SkEdgeClipper.h>

Public Member Functions
	SkEdgeClipper (bool canCullToTheRight)
bool	clipLine (SkPoint p0, SkPoint p1, const SkRect &clip)
bool	clipQuad (const SkPoint pts[3], const SkRect &clip)
bool	clipCubic (const SkPoint pts[4], const SkRect &clip)
SkPath::Verb	next (SkPoint pts[])
bool	canCullToTheRight () const

Static Public Member Functions
static void	ClipPath (const SkPath &path, const SkRect &clip, bool canCullToTheRight, void(*consume)(SkEdgeClipper *, bool newCtr, void *ctx), void *ctx)

Detailed Description

This is basically an iterator. It is initialized with an edge and a clip, and then next() is called until it returns kDone_Verb.

Definition at line 22 of file SkEdgeClipper.h.

Constructor & Destructor Documentation

SkEdgeClipper()

SkEdgeClipper::SkEdgeClipper ( bool  canCullToTheRight )

inline

Definition at line 24 of file SkEdgeClipper.h.

: fCanCullToTheRight(canCullToTheRight) {}

Member Function Documentation

canCullToTheRight()

bool SkEdgeClipper::canCullToTheRight ( ) const

inline

Definition at line 32 of file SkEdgeClipper.h.

{ return fCanCullToTheRight; }

clipCubic()

bool SkEdgeClipper::clipCubic	(	const SkPoint	pts[4],
		const SkRect &	clip
	)

Definition at line 422 of file SkEdgeClipper.cpp.

                                                                         {
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
 
    const SkRect bounds = compute_cubic_bounds(srcPts);
    // check if we're clipped out vertically
    if (bounds.fBottom > clip.fTop && bounds.fTop < clip.fBottom) {
        if (too_big_for_reliable_float_math(bounds)) {
            // can't safely clip the cubic, so we give up and draw a line (which we can safely clip)
            //
            // If we rewrote chopcubicat*extrema and chopmonocubic using doubles, we could very
            // likely always handle the cubic safely, but (it seems) at a big loss in speed, so
            // we'd only want to take that alternate impl if needed. Perhaps a TODO to try it.
            //
            return this->clipLine(srcPts[0], srcPts[3], clip);
        } else {
            SkPoint monoY[10];
            int countY = SkChopCubicAtYExtrema(srcPts, monoY);
            for (int y = 0; y <= countY; y++) {
                SkPoint monoX[10];
                int countX = SkChopCubicAtXExtrema(&monoY[y * 3], monoX);
                for (int x = 0; x <= countX; x++) {
                    this->clipMonoCubic(&monoX[x * 3], clip);
                    SkASSERT(fCurrVerb - fVerbs < kMaxVerbs);
                    SkASSERT(fCurrPoint - fPoints <= kMaxPoints);
                }
            }
        }
    }
 
    *fCurrVerb = SkPath::kDone_Verb;
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
    return SkPath::kDone_Verb != fVerbs[0];
}

clipLine()

bool SkEdgeClipper::clipLine	(	SkPoint	p0,
		SkPoint	p1,
		const SkRect &	clip
	)

Definition at line 53 of file SkEdgeClipper.cpp.

                                                                       {
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
 
    SkPoint lines[SkLineClipper::kMaxPoints];
    const SkPoint pts[] = { p0, p1 };
    int lineCount = SkLineClipper::ClipLine(pts, clip, lines, fCanCullToTheRight);
    for (int i = 0; i < lineCount; i++) {
        this->appendLine(lines[i], lines[i + 1]);
    }
 
    *fCurrVerb = SkPath::kDone_Verb;
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
    return SkPath::kDone_Verb != fVerbs[0];
}

ClipPath()

void SkEdgeClipper::ClipPath ( const SkPath &  path, const SkRect &  clip, bool  canCullToTheRight, void(*)(SkEdgeClipper *, bool newCtr, void *ctx)  consume, void *  ctx  )

static

Clips each segment from the path, and passes the result (in a clipper) to the consume proc.

Definition at line 566 of file SkEdgeClipper.cpp.

                                                                                                 {
    SkASSERT(path.isFinite());
 
    SkAutoConicToQuads quadder;
    const SkScalar conicTol = SK_Scalar1 / 4;
 
    SkPathEdgeIter iter(path);
    SkEdgeClipper clipper(canCullToTheRight);
 
    while (auto e = iter.next()) {
        switch (e.fEdge) {
            case SkPathEdgeIter::Edge::kLine:
                if (clipper.clipLine(e.fPts[0], e.fPts[1], clip)) {
                    consume(&clipper, e.fIsNewContour, ctx);
                }
                break;
            case SkPathEdgeIter::Edge::kQuad:
                if (clipper.clipQuad(e.fPts, clip)) {
                    consume(&clipper, e.fIsNewContour, ctx);
                }
                break;
            case SkPathEdgeIter::Edge::kConic: {
                const SkPoint* quadPts = quadder.computeQuads(e.fPts, iter.conicWeight(), conicTol);
                for (int i = 0; i < quadder.countQuads(); ++i) {
                    if (clipper.clipQuad(quadPts, clip)) {
                        consume(&clipper, e.fIsNewContour, ctx);
                    }
                    quadPts += 2;
                }
            } break;
            case SkPathEdgeIter::Edge::kCubic:
                if (clipper.clipCubic(e.fPts, clip)) {
                    consume(&clipper, e.fIsNewContour, ctx);
                }
                break;
        }
    }
}

clipQuad()

bool SkEdgeClipper::clipQuad	(	const SkPoint	pts[3],
		const SkRect &	clip
	)

Definition at line 226 of file SkEdgeClipper.cpp.

                                                                        {
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
 
    SkRect  bounds;
    bounds.setBounds(srcPts, 3);
 
    if (!quick_reject(bounds, clip)) {
        SkPoint monoY[5];
        int countY = SkChopQuadAtYExtrema(srcPts, monoY);
        for (int y = 0; y <= countY; y++) {
            SkPoint monoX[5];
            int countX = SkChopQuadAtXExtrema(&monoY[y * 2], monoX);
            for (int x = 0; x <= countX; x++) {
                this->clipMonoQuad(&monoX[x * 2], clip);
                SkASSERT(fCurrVerb - fVerbs < kMaxVerbs);
                SkASSERT(fCurrPoint - fPoints <= kMaxPoints);
            }
        }
    }
 
    *fCurrVerb = SkPath::kDone_Verb;
    fCurrPoint = fPoints;
    fCurrVerb = fVerbs;
    return SkPath::kDone_Verb != fVerbs[0];
}

next()

SkPath::Verb SkEdgeClipper::next

(

SkPoint

pts[]

)

Definition at line 506 of file SkEdgeClipper.cpp.

                                            {
    SkPath::Verb verb = *fCurrVerb;
 
    switch (verb) {
        case SkPath::kLine_Verb:
            memcpy(pts, fCurrPoint, 2 * sizeof(SkPoint));
            fCurrPoint += 2;
            fCurrVerb += 1;
            break;
        case SkPath::kQuad_Verb:
            memcpy(pts, fCurrPoint, 3 * sizeof(SkPoint));
            fCurrPoint += 3;
            fCurrVerb += 1;
            break;
        case SkPath::kCubic_Verb:
            memcpy(pts, fCurrPoint, 4 * sizeof(SkPoint));
            fCurrPoint += 4;
            fCurrVerb += 1;
            break;
        case SkPath::kDone_Verb:
            break;
        default:
            SkDEBUGFAIL("unexpected verb in quadclippper2 iter");
            break;
    }
    return verb;
}

---

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

• third_party/skia/src/core/SkEdgeClipper.h
• third_party/skia/src/core/SkEdgeClipper.cpp