GrTriangulator Class Reference

#include <GrTriangulator.h>

Inheritance diagram for GrTriangulator:

Classes
class	BreadcrumbTriangleList
struct	Comparator
struct	Edge
struct	EdgeList
struct	Line
struct	MonotonePoly
struct	Poly
struct	Vertex
struct	VertexList

Public Types
enum	Side { kLeft_Side , kRight_Side }
enum class	EdgeType { kInner , kOuter , kConnector }

Static Public Member Functions
static int	PathToTriangles (const SkPath &path, SkScalar tolerance, const SkRect &clipBounds, GrEagerVertexAllocator *vertexAllocator, bool *isLinear)

Static Public Attributes
static constexpr int	kArenaDefaultChunkSize = 16 * 1024

Protected Types
enum class	SimplifyResult { kFailed , kAlreadySimple , kFoundSelfIntersection }
enum class	BoolFail { kFalse , kTrue , kFail }

Protected Member Functions
	GrTriangulator (const SkPath &path, SkArenaAlloc *alloc)
virtual	~GrTriangulator ()
void	pathToContours (float tolerance, const SkRect &clipBounds, VertexList *contours, bool *isLinear) const
void	contoursToMesh (VertexList *contours, int contourCnt, VertexList *mesh, const Comparator &)
SimplifyResult	simplify (VertexList *mesh, const Comparator &)
virtual std::tuple< Poly *, bool >	tessellate (const VertexList &vertices, const Comparator &)
skgpu::VertexWriter	polysToTriangles (Poly *polys, SkPathFillType overrideFillType, skgpu::VertexWriter data) const
skgpu::VertexWriter	emitMonotonePoly (const MonotonePoly *, skgpu::VertexWriter data) const
skgpu::VertexWriter	emitTriangle (Vertex *prev, Vertex *curr, Vertex *next, int winding, skgpu::VertexWriter data) const
skgpu::VertexWriter	emitPoly (const Poly *, skgpu::VertexWriter data) const
Poly *	makePoly (Poly **head, Vertex *v, int winding) const
void	appendPointToContour (const SkPoint &p, VertexList *contour) const
void	appendQuadraticToContour (const SkPoint[3], SkScalar toleranceSqd, VertexList *contour) const
void	generateCubicPoints (const SkPoint &, const SkPoint &, const SkPoint &, const SkPoint &, SkScalar tolSqd, VertexList *contour, int pointsLeft) const
bool	applyFillType (int winding) const
MonotonePoly *	allocateMonotonePoly (Edge *edge, Side side, int winding)
Edge *	allocateEdge (Vertex *top, Vertex *bottom, int winding, EdgeType type)
Edge *	makeEdge (Vertex *prev, Vertex *next, EdgeType type, const Comparator &)
bool	setTop (Edge *edge, Vertex *v, EdgeList *activeEdges, Vertex **current, const Comparator &) const
bool	setBottom (Edge *edge, Vertex *v, EdgeList *activeEdges, Vertex **current, const Comparator &) const
bool	mergeEdgesAbove (Edge *edge, Edge *other, EdgeList *activeEdges, Vertex **current, const Comparator &) const
bool	mergeEdgesBelow (Edge *edge, Edge *other, EdgeList *activeEdges, Vertex **current, const Comparator &) const
Edge *	makeConnectingEdge (Vertex *prev, Vertex *next, EdgeType, const Comparator &, int windingScale=1)
void	mergeVertices (Vertex *src, Vertex *dst, VertexList *mesh, const Comparator &) const
bool	mergeCollinearEdges (Edge *edge, EdgeList *activeEdges, Vertex **current, const Comparator &) const
BoolFail	splitEdge (Edge *edge, Vertex *v, EdgeList *activeEdges, Vertex **current, const Comparator &)
BoolFail	intersectEdgePair (Edge *left, Edge *right, EdgeList *activeEdges, Vertex **current, const Comparator &)
Vertex *	makeSortedVertex (const SkPoint &, uint8_t alpha, VertexList *mesh, Vertex *reference, const Comparator &) const
void	computeBisector (Edge *edge1, Edge *edge2, Vertex *) const
BoolFail	checkForIntersection (Edge *left, Edge *right, EdgeList *activeEdges, Vertex **current, VertexList *mesh, const Comparator &)
void	sanitizeContours (VertexList *contours, int contourCnt) const
bool	mergeCoincidentVertices (VertexList *mesh, const Comparator &) const
void	buildEdges (VertexList *contours, int contourCnt, VertexList *mesh, const Comparator &)
std::tuple< Poly *, bool >	contoursToPolys (VertexList *contours, int contourCnt)
std::tuple< Poly *, bool >	pathToPolys (float tolerance, const SkRect &clipBounds, bool *isLinear)
int	polysToTriangles (Poly *, GrEagerVertexAllocator *) const

Static Protected Member Functions
static void	SortedMerge (VertexList *front, VertexList *back, VertexList *result, const Comparator &)
static void	SortMesh (VertexList *vertices, const Comparator &)
static void	FindEnclosingEdges (const Vertex &v, const EdgeList &edges, Edge **left, Edge **right)
static int64_t	CountPoints (Poly *polys, SkPathFillType overrideFillType)

Protected Attributes
const SkPath	fPath
SkArenaAlloc *const	fAlloc
int	fNumMonotonePolys = 0
int	fNumEdges = 0
bool	fRoundVerticesToQuarterPixel = false
bool	fEmitCoverage = false
bool	fPreserveCollinearVertices = false
bool	fCollectBreadcrumbTriangles = false
BreadcrumbTriangleList	fBreadcrumbList

Detailed Description

Provides utility functions for converting paths to a collection of triangles.

Definition at line 35 of file GrTriangulator.h.

Member Enumeration Documentation

BoolFail

enum class GrTriangulator::BoolFail

strongprotected

Enumerator
kFalse
kTrue
kFail

Definition at line 94 of file GrTriangulator.h.

                        {
        kFalse,
        kTrue,
        kFail
    };

EdgeType

enum class GrTriangulator::EdgeType

strong

Enumerator
kInner
kOuter
kConnector

Definition at line 56 of file GrTriangulator.h.

{ kInner, kOuter, kConnector };

Side

enum GrTriangulator::Side

Enumerator
kLeft_Side
kRight_Side

Definition at line 55 of file GrTriangulator.h.

{ kLeft_Side, kRight_Side } Side;

SimplifyResult

enum class GrTriangulator::SimplifyResult

strongprotected

Enumerator
kFailed
kAlreadySimple
kFoundSelfIntersection

Definition at line 88 of file GrTriangulator.h.

                              {
        kFailed,
        kAlreadySimple,
        kFoundSelfIntersection
    };

Constructor & Destructor Documentation

GrTriangulator()

GrTriangulator::GrTriangulator ( const SkPath &  path, SkArenaAlloc *  alloc  )

inlineprotected

Definition at line 69 of file GrTriangulator.h.

: fPath(path), fAlloc(alloc) {}

~GrTriangulator()

virtual GrTriangulator::~GrTriangulator ( )

inlineprotectedvirtual

Definition at line 70 of file GrTriangulator.h.

{}

Member Function Documentation

allocateEdge()

Edge * GrTriangulator::allocateEdge ( Vertex *  top, Vertex *  bottom, int  winding, EdgeType  type  )

protected

Definition at line 643 of file GrTriangulator.cpp.

                                                                                          {
    ++fNumEdges;
    return fAlloc->make<Edge>(top, bottom, winding, type);
}

allocateMonotonePoly()

MonotonePoly * GrTriangulator::allocateMonotonePoly ( Edge *  edge, Side  side, int  winding  )

protected

Definition at line 638 of file GrTriangulator.cpp.

                                                                                     {
    ++fNumMonotonePolys;
    return fAlloc->make<MonotonePoly>(edge, side, winding);
}

appendPointToContour()

void GrTriangulator::appendPointToContour ( const SkPoint &  p, VertexList *  contour  ) const

protected

Definition at line 475 of file GrTriangulator.cpp.

                                                                                     {
    Vertex* v = fAlloc->make<Vertex>(p, 255);
#if TRIANGULATOR_LOGGING
    static float gID = 0.0f;
    v->fID = gID++;
#endif
    contour->append(v);
}

appendQuadraticToContour()

void GrTriangulator::appendQuadraticToContour ( const SkPoint  pts[3], SkScalar  toleranceSqd, VertexList *  contour  ) const

protected

Definition at line 495 of file GrTriangulator.cpp.

                                                                         {
    SkQuadCoeff quad(pts);
    skvx::float2 aa = quad.fA * quad.fA;
    SkScalar denom = 2.0f * (aa[0] + aa[1]);
    skvx::float2 ab = quad.fA * quad.fB;
    SkScalar t = denom ? (-ab[0] - ab[1]) / denom : 0.0f;
    int nPoints = 1;
    SkScalar u = 1.0f;
    // Test possible subdivision values only at the point of maximum curvature.
    // If it passes the flatness metric there, it'll pass everywhere.
    while (nPoints < GrPathUtils::kMaxPointsPerCurve) {
        u = 1.0f / nPoints;
        if (quad_error_at(pts, t, u) < toleranceSqd) {
            break;
        }
        nPoints++;
    }
    for (int j = 1; j <= nPoints; j++) {
        this->appendPointToContour(to_point(quad.eval(j * u)), contour);
    }
}

applyFillType()

bool GrTriangulator::applyFillType ( int  winding ) const

protected

Definition at line 630 of file GrTriangulator.cpp.

                                                    {
    return apply_fill_type(fPath.getFillType(), winding);
}

buildEdges()

void GrTriangulator::buildEdges ( VertexList *  contours, int  contourCnt, VertexList *  mesh, const Comparator &  c  )

protected

Definition at line 1303 of file GrTriangulator.cpp.

                                                     {
    for (VertexList* contour = contours; contourCnt > 0; --contourCnt, ++contour) {
        Vertex* prev = contour->fTail;
        for (Vertex* v = contour->fHead; v;) {
            Vertex* next = v->fNext;
            this->makeConnectingEdge(prev, v, EdgeType::kInner, c);
            mesh->append(v);
            prev = v;
            v = next;
        }
    }
}

checkForIntersection()

GrTriangulator::BoolFail GrTriangulator::checkForIntersection ( Edge *  left, Edge *  right, EdgeList *  activeEdges, Vertex **  current, VertexList *  mesh, const Comparator &  c  )

protected

Definition at line 1187 of file GrTriangulator.cpp.

                             {
    if (!left || !right) {
        return BoolFail::kFalse;
    }
    SkPoint p;
    uint8_t alpha;
    // If we are going to call intersect, then there must be tops and bottoms.
    if (!left->fTop || !left->fBottom || !right->fTop || !right->fBottom) {
        return BoolFail::kFail;
    }
    if (left->intersect(*right, &p, &alpha) && p.isFinite()) {
        Vertex* v;
        TESS_LOG("found intersection, pt is %g, %g\n", p.fX, p.fY);
        Vertex* top = *current;
        // If the intersection point is above the current vertex, rewind to the vertex above the
        // intersection.
        while (top && c.sweep_lt(p, top->fPoint)) {
            top = top->fPrev;
        }
 
        // Always clamp the intersection to lie between the vertices of each segment, since
        // in theory that's where the intersection is, but in reality, floating point error may
        // have computed an intersection beyond a vertex's component(s).
        p = clamp(p, left->fTop->fPoint, left->fBottom->fPoint, c);
        p = clamp(p, right->fTop->fPoint, right->fBottom->fPoint, c);
 
        if (coincident(p, left->fTop->fPoint)) {
            v = left->fTop;
        } else if (coincident(p, left->fBottom->fPoint)) {
            v = left->fBottom;
        } else if (coincident(p, right->fTop->fPoint)) {
            v = right->fTop;
        } else if (coincident(p, right->fBottom->fPoint)) {
            v = right->fBottom;
        } else {
            v = this->makeSortedVertex(p, alpha, mesh, top, c);
            if (left->fTop->fPartner) {
                SkASSERT(fEmitCoverage);  // Edge-AA only!
                v->fSynthetic = true;
                this->computeBisector(left, right, v);
            }
        }
        if (!rewind(activeEdges, current, top ? top : v, c)) {
            return BoolFail::kFail;
        }
        if (this->splitEdge(left, v, activeEdges, current, c) == BoolFail::kFail) {
            return BoolFail::kFail;
        }
        if (this->splitEdge(right, v, activeEdges, current, c) == BoolFail::kFail) {
            return BoolFail::kFail;
        }
        v->fAlpha = std::max(v->fAlpha, alpha);
        return BoolFail::kTrue;
    }
    return this->intersectEdgePair(left, right, activeEdges, current, c);
}

computeBisector()

void GrTriangulator::computeBisector ( Edge *  edge1, Edge *  edge2, Vertex *  v  ) const

protected

Definition at line 1167 of file GrTriangulator.cpp.

                                                                              {
    SkASSERT(fEmitCoverage);  // Edge-AA only!
    Line line1 = edge1->fLine;
    Line line2 = edge2->fLine;
    line1.normalize();
    line2.normalize();
    double cosAngle = line1.fA * line2.fA + line1.fB * line2.fB;
    if (cosAngle > 0.999) {
        return;
    }
    line1.fC += edge1->fWinding > 0 ? -1 : 1;
    line2.fC += edge2->fWinding > 0 ? -1 : 1;
    SkPoint p;
    if (line1.intersect(line2, &p)) {
        uint8_t alpha = edge1->fType == EdgeType::kOuter ? 255 : 0;
        v->fPartner = fAlloc->make<Vertex>(p, alpha);
        TESS_LOG("computed bisector (%g,%g) alpha %d for vertex %g\n", p.fX, p.fY, alpha, v->fID);
    }
}

contoursToMesh()

void GrTriangulator::contoursToMesh ( VertexList *  contours, int  contourCnt, VertexList *  mesh, const Comparator &  c  )

protected

Definition at line 1648 of file GrTriangulator.cpp.

                                                         {
#if TRIANGULATOR_LOGGING
    for (int i = 0; i < contourCnt; ++i) {
        Vertex* v = contours[i].fHead;
        SkASSERT(v);
        TESS_LOG("path.moveTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
        for (v = v->fNext; v; v = v->fNext) {
            TESS_LOG("path.lineTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
        }
    }
#endif
    this->sanitizeContours(contours, contourCnt);
    this->buildEdges(contours, contourCnt, mesh, c);
}

contoursToPolys()

std::tuple< Poly *, bool > GrTriangulator::contoursToPolys ( VertexList *  contours, int  contourCnt  )

protected

Definition at line 1683 of file GrTriangulator.cpp.

                                                                                          {
    const SkRect& pathBounds = fPath.getBounds();
    Comparator c(pathBounds.width() > pathBounds.height() ? Comparator::Direction::kHorizontal
                                                          : Comparator::Direction::kVertical);
    VertexList mesh;
    this->contoursToMesh(contours, contourCnt, &mesh, c);
    TESS_LOG("\ninitial mesh:\n");
    DUMP_MESH(mesh);
    SortMesh(&mesh, c);
    TESS_LOG("\nsorted mesh:\n");
    DUMP_MESH(mesh);
    this->mergeCoincidentVertices(&mesh, c);
    TESS_LOG("\nsorted+merged mesh:\n");
    DUMP_MESH(mesh);
    auto result = this->simplify(&mesh, c);
    if (result == SimplifyResult::kFailed) {
        return { nullptr, false };
    }
    TESS_LOG("\nsimplified mesh:\n");
    DUMP_MESH(mesh);
    return this->tessellate(mesh, c);
}

CountPoints()

int64_t GrTriangulator::CountPoints ( Poly *  polys, SkPathFillType  overrideFillType  )

staticprotected

Definition at line 1768 of file GrTriangulator.cpp.

                                                                                {
    int64_t count = 0;
    for (Poly* poly = polys; poly; poly = poly->fNext) {
        if (apply_fill_type(overrideFillType, poly) && poly->fCount >= 3) {
            count += (poly->fCount - 2) * (TRIANGULATOR_WIREFRAME ? 6 : 3);
        }
    }
    return count;
}

emitMonotonePoly()

skgpu::VertexWriter GrTriangulator::emitMonotonePoly ( const MonotonePoly *  monotonePoly, skgpu::VertexWriter  data  ) const

protected

Definition at line 332 of file GrTriangulator.cpp.

                                                                                   {
    SkASSERT(monotonePoly->fWinding != 0);
    Edge* e = monotonePoly->fFirstEdge;
    VertexList vertices;
    vertices.append(e->fTop);
    int count = 1;
    while (e != nullptr) {
        if (kRight_Side == monotonePoly->fSide) {
            vertices.append(e->fBottom);
            e = e->fRightPolyNext;
        } else {
            vertices.prepend(e->fBottom);
            e = e->fLeftPolyNext;
        }
        count++;
    }
    Vertex* first = vertices.fHead;
    Vertex* v = first->fNext;
    while (v != vertices.fTail) {
        SkASSERT(v && v->fPrev && v->fNext);
        Vertex* prev = v->fPrev;
        Vertex* curr = v;
        Vertex* next = v->fNext;
        if (count == 3) {
            return this->emitTriangle(prev, curr, next, monotonePoly->fWinding, std::move(data));
        }
        double ax = static_cast<double>(curr->fPoint.fX) - prev->fPoint.fX;
        double ay = static_cast<double>(curr->fPoint.fY) - prev->fPoint.fY;
        double bx = static_cast<double>(next->fPoint.fX) - curr->fPoint.fX;
        double by = static_cast<double>(next->fPoint.fY) - curr->fPoint.fY;
        if (ax * by - ay * bx >= 0.0) {
            data = this->emitTriangle(prev, curr, next, monotonePoly->fWinding, std::move(data));
            v->fPrev->fNext = v->fNext;
            v->fNext->fPrev = v->fPrev;
            count--;
            if (v->fPrev == first) {
                v = v->fNext;
            } else {
                v = v->fPrev;
            }
        } else {
            v = v->fNext;
        }
    }
    return data;
}

emitPoly()

skgpu::VertexWriter GrTriangulator::emitPoly ( const Poly *  poly, skgpu::VertexWriter  data  ) const

protected

Definition at line 453 of file GrTriangulator.cpp.

                                                                                         {
    if (poly->fCount < 3) {
        return data;
    }
    TESS_LOG("emit() %d, size %d\n", poly->fID, poly->fCount);
    for (MonotonePoly* m = poly->fHead; m != nullptr; m = m->fNext) {
        data = this->emitMonotonePoly(m, std::move(data));
    }
    return data;
}

emitTriangle()

skgpu::VertexWriter GrTriangulator::emitTriangle ( Vertex *  prev, Vertex *  curr, Vertex *  next, int  winding, skgpu::VertexWriter  data  ) const

protected

Definition at line 380 of file GrTriangulator.cpp.

                                                                                             {
    if (winding > 0) {
        // Ensure our triangles always wind in the same direction as if the path had been
        // triangulated as a simple fan (a la red book).
        std::swap(prev, next);
    }
    if (fCollectBreadcrumbTriangles && abs(winding) > 1 &&
        fPath.getFillType() == SkPathFillType::kWinding) {
        // The first winding count will come from the actual triangle we emit. The remaining counts
        // come from the breadcrumb triangle.
        fBreadcrumbList.append(fAlloc, prev->fPoint, curr->fPoint, next->fPoint, abs(winding) - 1);
    }
    return emit_triangle(prev, curr, next, fEmitCoverage, std::move(data));
}

FindEnclosingEdges()

void GrTriangulator::FindEnclosingEdges ( const Vertex &  v, const EdgeList &  edges, Edge **  left, Edge **  right  )

staticprotected

Definition at line 668 of file GrTriangulator.cpp.

                                                                  {
    if (v.fFirstEdgeAbove && v.fLastEdgeAbove) {
        *left = v.fFirstEdgeAbove->fLeft;
        *right = v.fLastEdgeAbove->fRight;
        return;
    }
    Edge* next = nullptr;
    Edge* prev;
    for (prev = edges.fTail; prev != nullptr; prev = prev->fLeft) {
        if (prev->isLeftOf(v)) {
            break;
        }
        next = prev;
    }
    *left = prev;
    *right = next;
}

generateCubicPoints()

void GrTriangulator::generateCubicPoints ( const SkPoint &  p0, const SkPoint &  p1, const SkPoint &  p2, const SkPoint &  p3, SkScalar  tolSqd, VertexList *  contour, int  pointsLeft  ) const

protected

Definition at line 518 of file GrTriangulator.cpp.

                                                               {
    SkScalar d1 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3);
    SkScalar d2 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3);
    if (pointsLeft < 2 || (d1 < tolSqd && d2 < tolSqd) || !SkIsFinite(d1, d2)) {
        this->appendPointToContour(p3, contour);
        return;
    }
    const SkPoint q[] = {
        { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
        { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
        { SkScalarAve(p2.fX, p3.fX), SkScalarAve(p2.fY, p3.fY) }
    };
    const SkPoint r[] = {
        { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) },
        { SkScalarAve(q[1].fX, q[2].fX), SkScalarAve(q[1].fY, q[2].fY) }
    };
    const SkPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
    pointsLeft >>= 1;
    this->generateCubicPoints(p0, q[0], r[0], s, tolSqd, contour, pointsLeft);
    this->generateCubicPoints(s, r[1], q[2], p3, tolSqd, contour, pointsLeft);
}

intersectEdgePair()

GrTriangulator::BoolFail GrTriangulator::intersectEdgePair ( Edge *  left, Edge *  right, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  )

protected

Definition at line 1036 of file GrTriangulator.cpp.

                                                                                               {
    if (!left->fTop || !left->fBottom || !right->fTop || !right->fBottom) {
        return BoolFail::kFalse;
    }
    if (left->fTop == right->fTop || left->fBottom == right->fBottom) {
        return BoolFail::kFalse;
    }
 
    // Check if the lines intersect as determined by isLeftOf and isRightOf, since that is the
    // source of ground truth. It may suggest an intersection even if Edge::intersect() did not have
    // the precision to check it. In this case we are explicitly correcting the edge topology to
    // match the sided-ness checks.
    Edge* split = nullptr;
    Vertex* splitAt = nullptr;
    if (c.sweep_lt(left->fTop->fPoint, right->fTop->fPoint)) {
        if (!left->isLeftOf(*right->fTop)) {
            split = left;
            splitAt = right->fTop;
        }
    } else {
        if (!right->isRightOf(*left->fTop)) {
            split = right;
            splitAt = left->fTop;
        }
    }
    if (c.sweep_lt(right->fBottom->fPoint, left->fBottom->fPoint)) {
        if (!left->isLeftOf(*right->fBottom)) {
            split = left;
            splitAt = right->fBottom;
        }
    } else {
        if (!right->isRightOf(*left->fBottom)) {
            split = right;
            splitAt = left->fBottom;
        }
    }
 
    if (!split) {
        return BoolFail::kFalse;
    }
 
    // Rewind to the top of the edge that is "moving" since this topology correction can change the
    // geometry of the split edge.
    if (!rewind(activeEdges, current, split->fTop, c)) {
        return BoolFail::kFail;
    }
    return this->splitEdge(split, splitAt, activeEdges, current, c);
}

makeConnectingEdge()

Edge * GrTriangulator::makeConnectingEdge ( Vertex *  prev, Vertex *  next, EdgeType  type, const Comparator &  c, int  windingScale = 1  )

protected

Definition at line 1086 of file GrTriangulator.cpp.

                                                                                {
    if (!prev || !next || prev->fPoint == next->fPoint) {
        return nullptr;
    }
    Edge* edge = this->makeEdge(prev, next, type, c);
    edge->insertBelow(edge->fTop, c);
    edge->insertAbove(edge->fBottom, c);
    edge->fWinding *= windingScale;
    this->mergeCollinearEdges(edge, nullptr, nullptr, c);
    return edge;
}

makeEdge()

Edge * GrTriangulator::makeEdge ( Vertex *  prev, Vertex *  next, EdgeType  type, const Comparator &  c  )

protected

Definition at line 648 of file GrTriangulator.cpp.

                                                    {
    SkASSERT(prev->fPoint != next->fPoint);
    int winding = c.sweep_lt(prev->fPoint, next->fPoint) ? 1 : -1;
    Vertex* top = winding < 0 ? next : prev;
    Vertex* bottom = winding < 0 ? prev : next;
    return this->allocateEdge(top, bottom, winding, type);
}

makePoly()

Poly * GrTriangulator::makePoly ( Poly **  head, Vertex *  v, int  winding  ) const

protected

Definition at line 468 of file GrTriangulator.cpp.

                                                                        {
    Poly* poly = fAlloc->make<Poly>(v, winding);
    poly->fNext = *head;
    *head = poly;
    return poly;
}

makeSortedVertex()

Vertex * GrTriangulator::makeSortedVertex ( const SkPoint &  p, uint8_t  alpha, VertexList *  mesh, Vertex *  reference, const Comparator &  c  ) const

protected

Definition at line 1117 of file GrTriangulator.cpp.

                                                                                       {
    Vertex* prevV = reference;
    while (prevV && c.sweep_lt(p, prevV->fPoint)) {
        prevV = prevV->fPrev;
    }
    Vertex* nextV = prevV ? prevV->fNext : mesh->fHead;
    while (nextV && c.sweep_lt(nextV->fPoint, p)) {
        prevV = nextV;
        nextV = nextV->fNext;
    }
    Vertex* v;
    if (prevV && coincident(prevV->fPoint, p)) {
        v = prevV;
    } else if (nextV && coincident(nextV->fPoint, p)) {
        v = nextV;
    } else {
        v = fAlloc->make<Vertex>(p, alpha);
#if TRIANGULATOR_LOGGING
        if (!prevV) {
            v->fID = mesh->fHead->fID - 1.0f;
        } else if (!nextV) {
            v->fID = mesh->fTail->fID + 1.0f;
        } else {
            v->fID = (prevV->fID + nextV->fID) * 0.5f;
        }
#endif
        mesh->insert(v, prevV, nextV);
    }
    return v;
}

mergeCoincidentVertices()

bool GrTriangulator::mergeCoincidentVertices ( VertexList *  mesh, const Comparator &  c  ) const

protected

Definition at line 1282 of file GrTriangulator.cpp.

                                                                                        {
    if (!mesh->fHead) {
        return false;
    }
    bool merged = false;
    for (Vertex* v = mesh->fHead->fNext; v;) {
        Vertex* next = v->fNext;
        if (c.sweep_lt(v->fPoint, v->fPrev->fPoint)) {
            v->fPoint = v->fPrev->fPoint;
        }
        if (coincident(v->fPrev->fPoint, v->fPoint)) {
            this->mergeVertices(v, v->fPrev, mesh, c);
            merged = true;
        }
        v = next;
    }
    return merged;
}

mergeCollinearEdges()

bool GrTriangulator::mergeCollinearEdges ( Edge *  edge, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  ) const

protected

Definition at line 957 of file GrTriangulator.cpp.

                                                                    {
    for (;;) {
        if (top_collinear(edge->fPrevEdgeAbove, edge)) {
            if (!this->mergeEdgesAbove(edge->fPrevEdgeAbove, edge, activeEdges, current, c)) {
                return false;
            }
        } else if (top_collinear(edge, edge->fNextEdgeAbove)) {
            if (!this->mergeEdgesAbove(edge->fNextEdgeAbove, edge, activeEdges, current, c)) {
                return false;
            }
        } else if (bottom_collinear(edge->fPrevEdgeBelow, edge)) {
            if (!this->mergeEdgesBelow(edge->fPrevEdgeBelow, edge, activeEdges, current, c)) {
                return false;
            }
        } else if (bottom_collinear(edge, edge->fNextEdgeBelow)) {
            if (!this->mergeEdgesBelow(edge->fNextEdgeBelow, edge, activeEdges, current, c)) {
                return false;
            }
        } else {
            break;
        }
    }
    SkASSERT(!top_collinear(edge->fPrevEdgeAbove, edge));
    SkASSERT(!top_collinear(edge, edge->fNextEdgeAbove));
    SkASSERT(!bottom_collinear(edge->fPrevEdgeBelow, edge));
    SkASSERT(!bottom_collinear(edge, edge->fNextEdgeBelow));
    return true;
}

mergeEdgesAbove()

bool GrTriangulator::mergeEdgesAbove ( Edge *  edge, Edge *  other, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  ) const

protected

Definition at line 871 of file GrTriangulator.cpp.

                                                                                  {
    if (!edge || !other) {
        return false;
    }
    if (coincident(edge->fTop->fPoint, other->fTop->fPoint)) {
        TESS_LOG("merging coincident above edges (%g, %g) -> (%g, %g)\n",
                 edge->fTop->fPoint.fX, edge->fTop->fPoint.fY,
                 edge->fBottom->fPoint.fX, edge->fBottom->fPoint.fY);
        if (!rewind(activeEdges, current, edge->fTop, c)) {
            return false;
        }
        other->fWinding += edge->fWinding;
        edge->disconnect();
        edge->fTop = edge->fBottom = nullptr;
    } else if (c.sweep_lt(edge->fTop->fPoint, other->fTop->fPoint)) {
        if (!rewind(activeEdges, current, edge->fTop, c)) {
            return false;
        }
        other->fWinding += edge->fWinding;
        if (!this->setBottom(edge, other->fTop, activeEdges, current, c)) {
            return false;
        }
    } else {
        if (!rewind(activeEdges, current, other->fTop, c)) {
            return false;
        }
        edge->fWinding += other->fWinding;
        if (!this->setBottom(other, edge->fTop, activeEdges, current, c)) {
            return false;
        }
    }
    return true;
}

mergeEdgesBelow()

bool GrTriangulator::mergeEdgesBelow ( Edge *  edge, Edge *  other, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  ) const

protected

Definition at line 906 of file GrTriangulator.cpp.

                                                                                  {
    if (!edge || !other) {
        return false;
    }
    if (coincident(edge->fBottom->fPoint, other->fBottom->fPoint)) {
        TESS_LOG("merging coincident below edges (%g, %g) -> (%g, %g)\n",
                 edge->fTop->fPoint.fX, edge->fTop->fPoint.fY,
                 edge->fBottom->fPoint.fX, edge->fBottom->fPoint.fY);
        if (!rewind(activeEdges, current, edge->fTop, c)) {
            return false;
        }
        other->fWinding += edge->fWinding;
        edge->disconnect();
        edge->fTop = edge->fBottom = nullptr;
    } else if (c.sweep_lt(edge->fBottom->fPoint, other->fBottom->fPoint)) {
        if (!rewind(activeEdges, current, other->fTop, c)) {
            return false;
        }
        edge->fWinding += other->fWinding;
        if (!this->setTop(other, edge->fBottom, activeEdges, current, c)) {
            return false;
        }
    } else {
        if (!rewind(activeEdges, current, edge->fTop, c)) {
            return false;
        }
        other->fWinding += edge->fWinding;
        if (!this->setTop(edge, other->fBottom, activeEdges, current, c)) {
            return false;
        }
    }
    return true;
}

mergeVertices()

void GrTriangulator::mergeVertices ( Vertex *  src, Vertex *  dst, VertexList *  mesh, const Comparator &  c  ) const

protected

Definition at line 1099 of file GrTriangulator.cpp.

                                                              {
    TESS_LOG("found coincident verts at %g, %g; merging %g into %g\n",
             src->fPoint.fX, src->fPoint.fY, src->fID, dst->fID);
    dst->fAlpha = std::max(src->fAlpha, dst->fAlpha);
    if (src->fPartner) {
        src->fPartner->fPartner = dst;
    }
    while (Edge* edge = src->fFirstEdgeAbove) {
        std::ignore = this->setBottom(edge, dst, nullptr, nullptr, c);
    }
    while (Edge* edge = src->fFirstEdgeBelow) {
        std::ignore = this->setTop(edge, dst, nullptr, nullptr, c);
    }
    mesh->remove(src);
    dst->fSynthetic = true;
}

pathToContours()

void GrTriangulator::pathToContours ( float  tolerance, const SkRect &  clipBounds, VertexList *  contours, bool *  isLinear  ) const

protected

Definition at line 544 of file GrTriangulator.cpp.

                                                                                {
    SkScalar toleranceSqd = tolerance * tolerance;
    SkPoint pts[4];
    *isLinear = true;
    VertexList* contour = contours;
    SkPath::Iter iter(fPath, false);
    if (fPath.isInverseFillType()) {
        SkPoint quad[4];
        clipBounds.toQuad(quad);
        for (int i = 3; i >= 0; i--) {
            this->appendPointToContour(quad[i], contours);
        }
        contour++;
    }
    SkAutoConicToQuads converter;
    SkPath::Verb verb;
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        switch (verb) {
            case SkPath::kConic_Verb: {
                *isLinear = false;
                if (toleranceSqd == 0) {
                    this->appendPointToContour(pts[2], contour);
                    break;
                }
                SkScalar weight = iter.conicWeight();
                const SkPoint* quadPts = converter.computeQuads(pts, weight, toleranceSqd);
                for (int i = 0; i < converter.countQuads(); ++i) {
                    this->appendQuadraticToContour(quadPts, toleranceSqd, contour);
                    quadPts += 2;
                }
                break;
            }
            case SkPath::kMove_Verb:
                if (contour->fHead) {
                    contour++;
                }
                this->appendPointToContour(pts[0], contour);
                break;
            case SkPath::kLine_Verb: {
                this->appendPointToContour(pts[1], contour);
                break;
            }
            case SkPath::kQuad_Verb: {
                *isLinear = false;
                if (toleranceSqd == 0) {
                    this->appendPointToContour(pts[2], contour);
                    break;
                }
                this->appendQuadraticToContour(pts, toleranceSqd, contour);
                break;
            }
            case SkPath::kCubic_Verb: {
                *isLinear = false;
                if (toleranceSqd == 0) {
                    this->appendPointToContour(pts[3], contour);
                    break;
                }
                int pointsLeft = GrPathUtils::cubicPointCount(pts, tolerance);
                this->generateCubicPoints(pts[0], pts[1], pts[2], pts[3], toleranceSqd, contour,
                                          pointsLeft);
                break;
            }
            case SkPath::kClose_Verb:
            case SkPath::kDone_Verb:
                break;
        }
    }
}

pathToPolys()

std::tuple< Poly *, bool > GrTriangulator::pathToPolys ( float  tolerance, const SkRect &  clipBounds, bool *  isLinear  )

protected

Definition at line 1752 of file GrTriangulator.cpp.

                                                                                                           {
    int contourCnt = get_contour_count(fPath, tolerance);
    if (contourCnt <= 0) {
        *isLinear = true;
        return { nullptr, true };
    }
 
    if (SkPathFillType_IsInverse(fPath.getFillType())) {
        contourCnt++;
    }
    std::unique_ptr<VertexList[]> contours(new VertexList[contourCnt]);
 
    this->pathToContours(tolerance, clipBounds, contours.get(), isLinear);
    return this->contoursToPolys(contours.get(), contourCnt);
}

PathToTriangles()

static int GrTriangulator::PathToTriangles ( const SkPath &  path, SkScalar  tolerance, const SkRect &  clipBounds, GrEagerVertexAllocator *  vertexAllocator, bool *  isLinear  )

inlinestatic

Definition at line 39 of file GrTriangulator.h.

                                                                                        {
        if (!path.isFinite()) {
            return 0;
        }
        SkArenaAlloc alloc(kArenaDefaultChunkSize);
        GrTriangulator triangulator(path, &alloc);
        auto [ polys, success ] = triangulator.pathToPolys(tolerance, clipBounds, isLinear);
        if (!success) {
            return 0;
        }
        int count = triangulator.polysToTriangles(polys, vertexAllocator);
        return count;
    }

polysToTriangles() [1/2]

int GrTriangulator::polysToTriangles ( Poly *  polys, GrEagerVertexAllocator *  vertexAllocator  ) const

protected

Definition at line 1780 of file GrTriangulator.cpp.

                                                                                               {
    int64_t count64 = CountPoints(polys, fPath.getFillType());
    if (0 == count64 || count64 > SK_MaxS32) {
        return 0;
    }
    int count = count64;
 
    size_t vertexStride = sizeof(SkPoint);
    if (fEmitCoverage) {
        vertexStride += sizeof(float);
    }
    skgpu::VertexWriter verts = vertexAllocator->lockWriter(vertexStride, count);
    if (!verts) {
        SkDebugf("Could not allocate vertices\n");
        return 0;
    }
 
    TESS_LOG("emitting %d verts\n", count);
 
    skgpu::BufferWriter::Mark start = verts.mark();
    verts = this->polysToTriangles(polys, fPath.getFillType(), std::move(verts));
 
    int actualCount = static_cast<int>((verts.mark() - start) / vertexStride);
    SkASSERT(actualCount <= count);
    vertexAllocator->unlock(actualCount);
    return actualCount;
}

polysToTriangles() [2/2]

skgpu::VertexWriter GrTriangulator::polysToTriangles ( Poly *  polys, SkPathFillType  overrideFillType, skgpu::VertexWriter  data  ) const

protected

Definition at line 1707 of file GrTriangulator.cpp.

                                                                                   {
    for (Poly* poly = polys; poly; poly = poly->fNext) {
        if (apply_fill_type(overrideFillType, poly)) {
            data = this->emitPoly(poly, std::move(data));
        }
    }
    return data;
}

sanitizeContours()

void GrTriangulator::sanitizeContours ( VertexList *  contours, int  contourCnt  ) const

protected

Definition at line 1247 of file GrTriangulator.cpp.

                                                                                {
    for (VertexList* contour = contours; contourCnt > 0; --contourCnt, ++contour) {
        SkASSERT(contour->fHead);
        Vertex* prev = contour->fTail;
        prev->fPoint.fX = double_to_clamped_scalar((double) prev->fPoint.fX);
        prev->fPoint.fY = double_to_clamped_scalar((double) prev->fPoint.fY);
        if (fRoundVerticesToQuarterPixel) {
            round(&prev->fPoint);
        }
        for (Vertex* v = contour->fHead; v;) {
            v->fPoint.fX = double_to_clamped_scalar((double) v->fPoint.fX);
            v->fPoint.fY = double_to_clamped_scalar((double) v->fPoint.fY);
            if (fRoundVerticesToQuarterPixel) {
                round(&v->fPoint);
            }
            Vertex* next = v->fNext;
            Vertex* nextWrap = next ? next : contour->fHead;
            if (coincident(prev->fPoint, v->fPoint)) {
                TESS_LOG("vertex %g,%g coincident; removing\n", v->fPoint.fX, v->fPoint.fY);
                contour->remove(v);
            } else if (!v->fPoint.isFinite()) {
                TESS_LOG("vertex %g,%g non-finite; removing\n", v->fPoint.fX, v->fPoint.fY);
                contour->remove(v);
            } else if (!fPreserveCollinearVertices &&
                       Line(prev->fPoint, nextWrap->fPoint).dist(v->fPoint) == 0.0) {
                TESS_LOG("vertex %g,%g collinear; removing\n", v->fPoint.fX, v->fPoint.fY);
                contour->remove(v);
            } else {
                prev = v;
            }
            v = next;
        }
    }
}

setBottom()

bool GrTriangulator::setBottom ( Edge *  edge, Vertex *  v, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  ) const

protected

Definition at line 855 of file GrTriangulator.cpp.

                                                          {
    remove_edge_above(edge);
    if (fCollectBreadcrumbTriangles) {
        fBreadcrumbList.append(fAlloc, edge->fTop->fPoint, edge->fBottom->fPoint, v->fPoint,
                               edge->fWinding);
    }
    edge->fBottom = v;
    edge->recompute();
    edge->insertAbove(v, c);
    if (!rewind_if_necessary(edge, activeEdges, current, c)) {
        return false;
    }
    return this->mergeCollinearEdges(edge, activeEdges, current, c);
}

setTop()

bool GrTriangulator::setTop ( Edge *  edge, Vertex *  v, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  ) const

protected

Definition at line 839 of file GrTriangulator.cpp.

                                                       {
    remove_edge_below(edge);
    if (fCollectBreadcrumbTriangles) {
        fBreadcrumbList.append(fAlloc, edge->fTop->fPoint, edge->fBottom->fPoint, v->fPoint,
                               edge->fWinding);
    }
    edge->fTop = v;
    edge->recompute();
    edge->insertBelow(v, c);
    if (!rewind_if_necessary(edge, activeEdges, current, c)) {
        return false;
    }
    return this->mergeCollinearEdges(edge, activeEdges, current, c);
}

simplify()

GrTriangulator::SimplifyResult GrTriangulator::simplify ( VertexList *  mesh, const Comparator &  c  )

protected

Definition at line 1438 of file GrTriangulator.cpp.

                                                                             {
    TESS_LOG("simplifying complex polygons\n");
 
    int initialNumEdges = fNumEdges;
    int numSelfIntersections = 0;
 
    EdgeList activeEdges;
    auto result = SimplifyResult::kAlreadySimple;
    for (Vertex* v = mesh->fHead; v != nullptr; v = v->fNext) {
        if (!v->isConnected()) {
            continue;
        }
 
        // The max increase across all skps, svgs and gms with only the triangulating and SW path
        // renderers enabled and with the triangulator's maxVerbCount set to the Chrome value is
        // 17x.
        if (fNumEdges > 170*initialNumEdges) {
            return SimplifyResult::kFailed;
        }
 
        // In pathological cases, a path can intersect itself millions of times. After 500,000
        // self-intersections are found, reject the path.
        if (numSelfIntersections > 500000) {
            return SimplifyResult::kFailed;
        }
 
        Edge* leftEnclosingEdge;
        Edge* rightEnclosingEdge;
        bool restartChecks;
        do {
            TESS_LOG("\nvertex %g: (%g,%g), alpha %d\n",
                     v->fID, v->fPoint.fX, v->fPoint.fY, v->fAlpha);
            restartChecks = false;
            FindEnclosingEdges(*v, activeEdges, &leftEnclosingEdge, &rightEnclosingEdge);
            v->fLeftEnclosingEdge = leftEnclosingEdge;
            v->fRightEnclosingEdge = rightEnclosingEdge;
            if (v->fFirstEdgeBelow) {
                for (Edge* edge = v->fFirstEdgeBelow; edge; edge = edge->fNextEdgeBelow) {
                    BoolFail l = this->checkForIntersection(
                            leftEnclosingEdge, edge, &activeEdges, &v, mesh, c);
                    if (l == BoolFail::kFail) {
                        return SimplifyResult::kFailed;
                    }
                    if (l == BoolFail::kFalse) {
                        BoolFail r = this->checkForIntersection(
                                edge, rightEnclosingEdge, &activeEdges, &v, mesh, c);
                        if (r == BoolFail::kFail) {
                            return SimplifyResult::kFailed;
                        }
                        if (r == BoolFail::kFalse) {
                            // Neither l and r are both false.
                            continue;
                        }
                    }
 
                    // Either l or r are true.
                    result = SimplifyResult::kFoundSelfIntersection;
                    restartChecks = true;
                    ++numSelfIntersections;
                    break;
                }  // for
            } else {
                BoolFail bf = this->checkForIntersection(
                        leftEnclosingEdge, rightEnclosingEdge, &activeEdges, &v, mesh, c);
                if (bf == BoolFail::kFail) {
                    return SimplifyResult::kFailed;
                }
                if (bf == BoolFail::kTrue) {
                    result = SimplifyResult::kFoundSelfIntersection;
                    restartChecks = true;
                    ++numSelfIntersections;
                }
            }
        } while (restartChecks);
#ifdef SK_DEBUG
        validate_edge_list(&activeEdges, c);
#endif
        for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) {
            if (!activeEdges.remove(e)) {
                return SimplifyResult::kFailed;
            }
        }
        Edge* leftEdge = leftEnclosingEdge;
        for (Edge* e = v->fFirstEdgeBelow; e; e = e->fNextEdgeBelow) {
            activeEdges.insert(e, leftEdge);
            leftEdge = e;
        }
    }
    SkASSERT(!activeEdges.fHead && !activeEdges.fTail);
    return result;
}

SortedMerge()

void GrTriangulator::SortedMerge ( VertexList *  front, VertexList *  back, VertexList *  result, const Comparator &  c  )

staticprotected

Definition at line 1336 of file GrTriangulator.cpp.

                                                      {
    if (c.fDirection == Comparator::Direction::kHorizontal) {
        sorted_merge<sweep_lt_horiz>(front, back, result);
    } else {
        sorted_merge<sweep_lt_vert>(front, back, result);
    }
#if TRIANGULATOR_LOGGING
    float id = 0.0f;
    for (Vertex* v = result->fHead; v; v = v->fNext) {
        v->fID = id++;
    }
#endif
}

SortMesh()

void GrTriangulator::SortMesh ( VertexList *  vertices, const Comparator &  c  )

staticprotected

Definition at line 1664 of file GrTriangulator.cpp.

                                                                       {
    if (!vertices || !vertices->fHead) {
        return;
    }
 
    // Sort vertices in Y (secondarily in X).
    if (c.fDirection == Comparator::Direction::kHorizontal) {
        merge_sort<sweep_lt_horiz>(vertices);
    } else {
        merge_sort<sweep_lt_vert>(vertices);
    }
#if TRIANGULATOR_LOGGING
    for (Vertex* v = vertices->fHead; v != nullptr; v = v->fNext) {
        static float gID = 0.0f;
        v->fID = gID++;
    }
#endif
}

splitEdge()

GrTriangulator::BoolFail GrTriangulator::splitEdge ( Edge *  edge, Vertex *  v, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  )

protected

Definition at line 987 of file GrTriangulator.cpp.

                                                                                             {
    if (!edge->fTop || !edge->fBottom || v == edge->fTop || v == edge->fBottom) {
        return BoolFail::kFalse;
    }
    TESS_LOG("splitting edge (%g -> %g) at vertex %g (%g, %g)\n",
             edge->fTop->fID, edge->fBottom->fID, v->fID, v->fPoint.fX, v->fPoint.fY);
    Vertex* top;
    Vertex* bottom;
    int winding = edge->fWinding;
    // Theoretically, and ideally, the edge betwee p0 and p1 is being split by v, and v is "between"
    // the segment end points according to c. This is equivalent to p0 < v < p1.  Unfortunately, if
    // v was clamped/rounded this relation doesn't always hold.
    if (c.sweep_lt(v->fPoint, edge->fTop->fPoint)) {
        // Actually "v < p0 < p1": update 'edge' to be v->p1 and add v->p0. We flip the winding on
        // the new edge so that it winds as if it were p0->v.
        top = v;
        bottom = edge->fTop;
        winding *= -1;
        if (!this->setTop(edge, v, activeEdges, current, c)) {
            return BoolFail::kFail;
        }
    } else if (c.sweep_lt(edge->fBottom->fPoint, v->fPoint)) {
        // Actually "p0 < p1 < v": update 'edge' to be p0->v and add p1->v. We flip the winding on
        // the new edge so that it winds as if it were v->p1.
        top = edge->fBottom;
        bottom = v;
        winding *= -1;
        if (!this->setBottom(edge, v, activeEdges, current, c)) {
            return BoolFail::kFail;
        }
    } else {
        // The ideal case, "p0 < v < p1": update 'edge' to be p0->v and add v->p1. Original winding
        // is valid for both edges.
        top = v;
        bottom = edge->fBottom;
        if (!this->setBottom(edge, v, activeEdges, current, c)) {
            return BoolFail::kFail;
        }
    }
    Edge* newEdge = this->allocateEdge(top, bottom, winding, edge->fType);
    newEdge->insertBelow(top, c);
    newEdge->insertAbove(bottom, c);
    if (!this->mergeCollinearEdges(newEdge, activeEdges, current, c)) {
        return BoolFail::kFail;
    }
    return BoolFail::kTrue;
}

tessellate()

std::tuple< Poly *, bool > GrTriangulator::tessellate ( const VertexList &  vertices, const Comparator &    )

protectedvirtual

Definition at line 1533 of file GrTriangulator.cpp.

                                                                                              {
    TESS_LOG("\ntessellating simple polygons\n");
    EdgeList activeEdges;
    Poly* polys = nullptr;
    for (Vertex* v = vertices.fHead; v != nullptr; v = v->fNext) {
        if (!v->isConnected()) {
            continue;
        }
#if TRIANGULATOR_LOGGING
        TESS_LOG("\nvertex %g: (%g,%g), alpha %d\n", v->fID, v->fPoint.fX, v->fPoint.fY, v->fAlpha);
#endif
        Edge* leftEnclosingEdge;
        Edge* rightEnclosingEdge;
        FindEnclosingEdges(*v, activeEdges, &leftEnclosingEdge, &rightEnclosingEdge);
        Poly* leftPoly;
        Poly* rightPoly;
        if (v->fFirstEdgeAbove) {
            leftPoly = v->fFirstEdgeAbove->fLeftPoly;
            rightPoly = v->fLastEdgeAbove->fRightPoly;
        } else {
            leftPoly = leftEnclosingEdge ? leftEnclosingEdge->fRightPoly : nullptr;
            rightPoly = rightEnclosingEdge ? rightEnclosingEdge->fLeftPoly : nullptr;
        }
#if TRIANGULATOR_LOGGING
        TESS_LOG("edges above:\n");
        for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) {
            TESS_LOG("%g -> %g, lpoly %d, rpoly %d\n",
                     e->fTop->fID, e->fBottom->fID,
                     e->fLeftPoly ? e->fLeftPoly->fID : -1,
                     e->fRightPoly ? e->fRightPoly->fID : -1);
        }
        TESS_LOG("edges below:\n");
        for (Edge* e = v->fFirstEdgeBelow; e; e = e->fNextEdgeBelow) {
            TESS_LOG("%g -> %g, lpoly %d, rpoly %d\n",
                     e->fTop->fID, e->fBottom->fID,
                     e->fLeftPoly ? e->fLeftPoly->fID : -1,
                     e->fRightPoly ? e->fRightPoly->fID : -1);
        }
#endif
        if (v->fFirstEdgeAbove) {
            if (leftPoly) {
                leftPoly = leftPoly->addEdge(v->fFirstEdgeAbove, kRight_Side, this);
            }
            if (rightPoly) {
                rightPoly = rightPoly->addEdge(v->fLastEdgeAbove, kLeft_Side, this);
            }
            for (Edge* e = v->fFirstEdgeAbove; e != v->fLastEdgeAbove; e = e->fNextEdgeAbove) {
                Edge* rightEdge = e->fNextEdgeAbove;
                activeEdges.remove(e);
                if (e->fRightPoly) {
                    e->fRightPoly->addEdge(e, kLeft_Side, this);
                }
                if (rightEdge->fLeftPoly && rightEdge->fLeftPoly != e->fRightPoly) {
                    rightEdge->fLeftPoly->addEdge(e, kRight_Side, this);
                }
            }
            activeEdges.remove(v->fLastEdgeAbove);
            if (!v->fFirstEdgeBelow) {
                if (leftPoly && rightPoly && leftPoly != rightPoly) {
                    SkASSERT(leftPoly->fPartner == nullptr && rightPoly->fPartner == nullptr);
                    rightPoly->fPartner = leftPoly;
                    leftPoly->fPartner = rightPoly;
                }
            }
        }
        if (v->fFirstEdgeBelow) {
            if (!v->fFirstEdgeAbove) {
                if (leftPoly && rightPoly) {
                    if (leftPoly == rightPoly) {
                        if (leftPoly->fTail && leftPoly->fTail->fSide == kLeft_Side) {
                            leftPoly = this->makePoly(&polys, leftPoly->lastVertex(),
                                                      leftPoly->fWinding);
                            leftEnclosingEdge->fRightPoly = leftPoly;
                        } else {
                            rightPoly = this->makePoly(&polys, rightPoly->lastVertex(),
                                                       rightPoly->fWinding);
                            rightEnclosingEdge->fLeftPoly = rightPoly;
                        }
                    }
                    Edge* join = this->allocateEdge(leftPoly->lastVertex(), v, 1, EdgeType::kInner);
                    leftPoly = leftPoly->addEdge(join, kRight_Side, this);
                    rightPoly = rightPoly->addEdge(join, kLeft_Side, this);
                }
            }
            Edge* leftEdge = v->fFirstEdgeBelow;
            leftEdge->fLeftPoly = leftPoly;
            activeEdges.insert(leftEdge, leftEnclosingEdge);
            for (Edge* rightEdge = leftEdge->fNextEdgeBelow; rightEdge;
                 rightEdge = rightEdge->fNextEdgeBelow) {
                activeEdges.insert(rightEdge, leftEdge);
                int winding = leftEdge->fLeftPoly ? leftEdge->fLeftPoly->fWinding : 0;
                winding += leftEdge->fWinding;
                if (winding != 0) {
                    Poly* poly = this->makePoly(&polys, v, winding);
                    leftEdge->fRightPoly = rightEdge->fLeftPoly = poly;
                }
                leftEdge = rightEdge;
            }
            v->fLastEdgeBelow->fRightPoly = rightPoly;
        }
#if TRIANGULATOR_LOGGING
        TESS_LOG("\nactive edges:\n");
        for (Edge* e = activeEdges.fHead; e != nullptr; e = e->fRight) {
            TESS_LOG("%g -> %g, lpoly %d, rpoly %d\n",
                     e->fTop->fID, e->fBottom->fID,
                     e->fLeftPoly ? e->fLeftPoly->fID : -1,
                     e->fRightPoly ? e->fRightPoly->fID : -1);
        }
#endif
    }
    return { polys, true };
}

Member Data Documentation

fAlloc

SkArenaAlloc* const GrTriangulator::fAlloc

protected

Definition at line 205 of file GrTriangulator.h.

fBreadcrumbList

BreadcrumbTriangleList GrTriangulator::fBreadcrumbList

mutableprotected

Definition at line 280 of file GrTriangulator.h.

fCollectBreadcrumbTriangles

bool GrTriangulator::fCollectBreadcrumbTriangles = false

protected

Definition at line 213 of file GrTriangulator.h.

fEmitCoverage

bool GrTriangulator::fEmitCoverage = false

protected

Definition at line 211 of file GrTriangulator.h.

fNumEdges

int GrTriangulator::fNumEdges = 0

protected

Definition at line 207 of file GrTriangulator.h.

fNumMonotonePolys

int GrTriangulator::fNumMonotonePolys = 0

protected

Definition at line 206 of file GrTriangulator.h.

fPath

const SkPath GrTriangulator::fPath

protected

Definition at line 204 of file GrTriangulator.h.

fPreserveCollinearVertices

bool GrTriangulator::fPreserveCollinearVertices = false

protected

Definition at line 212 of file GrTriangulator.h.

fRoundVerticesToQuarterPixel

bool GrTriangulator::fRoundVerticesToQuarterPixel = false

protected

Definition at line 210 of file GrTriangulator.h.

kArenaDefaultChunkSize

constexpr int GrTriangulator::kArenaDefaultChunkSize = 16 * 1024

staticconstexpr

Definition at line 37 of file GrTriangulator.h.

---

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

• third_party/skia/src/gpu/ganesh/geometry/GrTriangulator.h
• third_party/skia/src/gpu/ganesh/geometry/GrTriangulator.cpp