| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/GrTriangulator.h" |
| |
| #include "src/gpu/GrEagerVertexAllocator.h" |
| #include "src/gpu/GrVertexWriter.h" |
| #include "src/gpu/geometry/GrPathUtils.h" |
| |
| #include "src/core/SkGeometry.h" |
| #include "src/core/SkPointPriv.h" |
| |
| #include <algorithm> |
| |
| |
| #if TRIANGULATOR_LOGGING |
| #define TESS_LOG printf |
| #define DUMP_MESH(M) (M).dump() |
| #else |
| #define TESS_LOG(...) |
| #define DUMP_MESH(M) |
| #endif |
| |
| using EdgeType = GrTriangulator::EdgeType; |
| using Vertex = GrTriangulator::Vertex; |
| using VertexList = GrTriangulator::VertexList; |
| using Line = GrTriangulator::Line; |
| using Edge = GrTriangulator::Edge; |
| using EdgeList = GrTriangulator::EdgeList; |
| using Poly = GrTriangulator::Poly; |
| using MonotonePoly = GrTriangulator::MonotonePoly; |
| using Comparator = GrTriangulator::Comparator; |
| |
| template <class T, T* T::*Prev, T* T::*Next> |
| static void list_insert(T* t, T* prev, T* next, T** head, T** tail) { |
| t->*Prev = prev; |
| t->*Next = next; |
| if (prev) { |
| prev->*Next = t; |
| } else if (head) { |
| *head = t; |
| } |
| if (next) { |
| next->*Prev = t; |
| } else if (tail) { |
| *tail = t; |
| } |
| } |
| |
| template <class T, T* T::*Prev, T* T::*Next> |
| static void list_remove(T* t, T** head, T** tail) { |
| if (t->*Prev) { |
| t->*Prev->*Next = t->*Next; |
| } else if (head) { |
| *head = t->*Next; |
| } |
| if (t->*Next) { |
| t->*Next->*Prev = t->*Prev; |
| } else if (tail) { |
| *tail = t->*Prev; |
| } |
| t->*Prev = t->*Next = nullptr; |
| } |
| |
| typedef bool (*CompareFunc)(const SkPoint& a, const SkPoint& b); |
| |
| static bool sweep_lt_horiz(const SkPoint& a, const SkPoint& b) { |
| return a.fX < b.fX || (a.fX == b.fX && a.fY > b.fY); |
| } |
| |
| static bool sweep_lt_vert(const SkPoint& a, const SkPoint& b) { |
| return a.fY < b.fY || (a.fY == b.fY && a.fX < b.fX); |
| } |
| |
| bool GrTriangulator::Comparator::sweep_lt(const SkPoint& a, const SkPoint& b) const { |
| return fDirection == Direction::kHorizontal ? sweep_lt_horiz(a, b) : sweep_lt_vert(a, b); |
| } |
| |
| static inline void* emit_vertex(Vertex* v, bool emitCoverage, void* data) { |
| GrVertexWriter verts{data}; |
| verts.write(v->fPoint); |
| |
| if (emitCoverage) { |
| verts.write(GrNormalizeByteToFloat(v->fAlpha)); |
| } |
| |
| return verts.fPtr; |
| } |
| |
| static void* emit_triangle(Vertex* v0, Vertex* v1, Vertex* v2, bool emitCoverage, void* data) { |
| TESS_LOG("emit_triangle %g (%g, %g) %d\n", v0->fID, v0->fPoint.fX, v0->fPoint.fY, v0->fAlpha); |
| TESS_LOG(" %g (%g, %g) %d\n", v1->fID, v1->fPoint.fX, v1->fPoint.fY, v1->fAlpha); |
| TESS_LOG(" %g (%g, %g) %d\n", v2->fID, v2->fPoint.fX, v2->fPoint.fY, v2->fAlpha); |
| #if TESSELLATOR_WIREFRAME |
| data = emit_vertex(v0, emitCoverage, data); |
| data = emit_vertex(v1, emitCoverage, data); |
| data = emit_vertex(v1, emitCoverage, data); |
| data = emit_vertex(v2, emitCoverage, data); |
| data = emit_vertex(v2, emitCoverage, data); |
| data = emit_vertex(v0, emitCoverage, data); |
| #else |
| data = emit_vertex(v0, emitCoverage, data); |
| data = emit_vertex(v1, emitCoverage, data); |
| data = emit_vertex(v2, emitCoverage, data); |
| #endif |
| return data; |
| } |
| |
| void GrTriangulator::VertexList::insert(Vertex* v, Vertex* prev, Vertex* next) { |
| list_insert<Vertex, &Vertex::fPrev, &Vertex::fNext>(v, prev, next, &fHead, &fTail); |
| } |
| |
| void GrTriangulator::VertexList::remove(Vertex* v) { |
| list_remove<Vertex, &Vertex::fPrev, &Vertex::fNext>(v, &fHead, &fTail); |
| } |
| |
| // Round to nearest quarter-pixel. This is used for screenspace tessellation. |
| |
| static inline void round(SkPoint* p) { |
| p->fX = SkScalarRoundToScalar(p->fX * SkFloatToScalar(4.0f)) * SkFloatToScalar(0.25f); |
| p->fY = SkScalarRoundToScalar(p->fY * SkFloatToScalar(4.0f)) * SkFloatToScalar(0.25f); |
| } |
| |
| static inline SkScalar double_to_clamped_scalar(double d) { |
| // Clamps large values to what's finitely representable when cast back to a float. |
| static const double kMaxLimit = (double) SK_ScalarMax; |
| // It's not perfect, but a using a value larger than float_min helps protect from denormalized |
| // values and ill-conditions in intermediate calculations on coordinates. |
| static const double kNearZeroLimit = 16 * (double) std::numeric_limits<float>::min(); |
| if (std::abs(d) < kNearZeroLimit) { |
| d = 0.f; |
| } |
| return SkDoubleToScalar(std::max(-kMaxLimit, std::min(d, kMaxLimit))); |
| } |
| |
| bool GrTriangulator::Line::intersect(const Line& other, SkPoint* point) const { |
| double denom = fA * other.fB - fB * other.fA; |
| if (denom == 0.0) { |
| return false; |
| } |
| double scale = 1.0 / denom; |
| point->fX = double_to_clamped_scalar((fB * other.fC - other.fB * fC) * scale); |
| point->fY = double_to_clamped_scalar((other.fA * fC - fA * other.fC) * scale); |
| round(point); |
| return point->isFinite(); |
| } |
| |
| bool GrTriangulator::Edge::intersect(const Edge& other, SkPoint* p, uint8_t* alpha) const { |
| TESS_LOG("intersecting %g -> %g with %g -> %g\n", |
| fTop->fID, fBottom->fID, other.fTop->fID, other.fBottom->fID); |
| if (fTop == other.fTop || fBottom == other.fBottom) { |
| return false; |
| } |
| double denom = fLine.fA * other.fLine.fB - fLine.fB * other.fLine.fA; |
| if (denom == 0.0) { |
| return false; |
| } |
| double dx = static_cast<double>(other.fTop->fPoint.fX) - fTop->fPoint.fX; |
| double dy = static_cast<double>(other.fTop->fPoint.fY) - fTop->fPoint.fY; |
| double sNumer = dy * other.fLine.fB + dx * other.fLine.fA; |
| double tNumer = dy * fLine.fB + dx * fLine.fA; |
| // If (sNumer / denom) or (tNumer / denom) is not in [0..1], exit early. |
| // This saves us doing the divide below unless absolutely necessary. |
| if (denom > 0.0 ? (sNumer < 0.0 || sNumer > denom || tNumer < 0.0 || tNumer > denom) |
| : (sNumer > 0.0 || sNumer < denom || tNumer > 0.0 || tNumer < denom)) { |
| return false; |
| } |
| double s = sNumer / denom; |
| SkASSERT(s >= 0.0 && s <= 1.0); |
| p->fX = double_to_clamped_scalar(fTop->fPoint.fX - s * fLine.fB); |
| p->fY = double_to_clamped_scalar(fTop->fPoint.fY + s * fLine.fA); |
| if (alpha) { |
| if (fType == EdgeType::kInner || other.fType == EdgeType::kInner) { |
| // If the intersection is on any interior edge, it needs to stay fully opaque or later |
| // triangulation could leech transparency into the inner fill region. |
| *alpha = 255; |
| } else if (fType == EdgeType::kOuter && other.fType == EdgeType::kOuter) { |
| // Trivially, the intersection will be fully transparent since since it is by |
| // construction on the outer edge. |
| *alpha = 0; |
| } else { |
| // Could be two connectors crossing, or a connector crossing an outer edge. |
| // Take the max interpolated alpha |
| SkASSERT(fType == EdgeType::kConnector || other.fType == EdgeType::kConnector); |
| double t = tNumer / denom; |
| *alpha = std::max((1.0 - s) * fTop->fAlpha + s * fBottom->fAlpha, |
| (1.0 - t) * other.fTop->fAlpha + t * other.fBottom->fAlpha); |
| } |
| } |
| return true; |
| } |
| |
| void GrTriangulator::EdgeList::insert(Edge* edge, Edge* prev, Edge* next) { |
| list_insert<Edge, &Edge::fLeft, &Edge::fRight>(edge, prev, next, &fHead, &fTail); |
| } |
| |
| void GrTriangulator::EdgeList::remove(Edge* edge) { |
| TESS_LOG("removing edge %g -> %g\n", edge->fTop->fID, edge->fBottom->fID); |
| SkASSERT(this->contains(edge)); |
| list_remove<Edge, &Edge::fLeft, &Edge::fRight>(edge, &fHead, &fTail); |
| } |
| |
| void GrTriangulator::MonotonePoly::addEdge(Edge* edge) { |
| if (fSide == kRight_Side) { |
| SkASSERT(!edge->fUsedInRightPoly); |
| list_insert<Edge, &Edge::fRightPolyPrev, &Edge::fRightPolyNext>( |
| edge, fLastEdge, nullptr, &fFirstEdge, &fLastEdge); |
| edge->fUsedInRightPoly = true; |
| } else { |
| SkASSERT(!edge->fUsedInLeftPoly); |
| list_insert<Edge, &Edge::fLeftPolyPrev, &Edge::fLeftPolyNext>( |
| edge, fLastEdge, nullptr, &fFirstEdge, &fLastEdge); |
| edge->fUsedInLeftPoly = true; |
| } |
| } |
| |
| void* GrTriangulator::emitMonotonePoly(const MonotonePoly* monotonePoly, void* data) const { |
| 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, 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, 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; |
| } |
| |
| void* GrTriangulator::emitTriangle(Vertex* prev, Vertex* curr, Vertex* next, int winding, |
| void* data) const { |
| 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, data); |
| } |
| |
| GrTriangulator::Poly::Poly(Vertex* v, int winding) |
| : fFirstVertex(v) |
| , fWinding(winding) |
| , fHead(nullptr) |
| , fTail(nullptr) |
| , fNext(nullptr) |
| , fPartner(nullptr) |
| , fCount(0) |
| { |
| #if TRIANGULATOR_LOGGING |
| static int gID = 0; |
| fID = gID++; |
| TESS_LOG("*** created Poly %d\n", fID); |
| #endif |
| } |
| |
| Poly* GrTriangulator::Poly::addEdge(Edge* e, Side side, SkArenaAlloc* alloc) { |
| TESS_LOG("addEdge (%g -> %g) to poly %d, %s side\n", |
| e->fTop->fID, e->fBottom->fID, fID, side == kLeft_Side ? "left" : "right"); |
| Poly* partner = fPartner; |
| Poly* poly = this; |
| if (side == kRight_Side) { |
| if (e->fUsedInRightPoly) { |
| return this; |
| } |
| } else { |
| if (e->fUsedInLeftPoly) { |
| return this; |
| } |
| } |
| if (partner) { |
| fPartner = partner->fPartner = nullptr; |
| } |
| if (!fTail) { |
| fHead = fTail = alloc->make<MonotonePoly>(e, side, fWinding); |
| fCount += 2; |
| } else if (e->fBottom == fTail->fLastEdge->fBottom) { |
| return poly; |
| } else if (side == fTail->fSide) { |
| fTail->addEdge(e); |
| fCount++; |
| } else { |
| e = alloc->make<Edge>(fTail->fLastEdge->fBottom, e->fBottom, 1, EdgeType::kInner); |
| fTail->addEdge(e); |
| fCount++; |
| if (partner) { |
| partner->addEdge(e, side, alloc); |
| poly = partner; |
| } else { |
| MonotonePoly* m = alloc->make<MonotonePoly>(e, side, fWinding); |
| m->fPrev = fTail; |
| fTail->fNext = m; |
| fTail = m; |
| } |
| } |
| return poly; |
| } |
| void* GrTriangulator::emitPoly(const Poly* poly, void *data) const { |
| 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, data); |
| } |
| return data; |
| } |
| |
| static bool coincident(const SkPoint& a, const SkPoint& b) { |
| return a == b; |
| } |
| |
| Poly* GrTriangulator::makePoly(Poly** head, Vertex* v, int winding) const { |
| Poly* poly = fAlloc->make<Poly>(v, winding); |
| poly->fNext = *head; |
| *head = poly; |
| return poly; |
| } |
| |
| void GrTriangulator::appendPointToContour(const SkPoint& p, VertexList* contour) const { |
| Vertex* v = fAlloc->make<Vertex>(p, 255); |
| #if TRIANGULATOR_LOGGING |
| static float gID = 0.0f; |
| v->fID = gID++; |
| #endif |
| contour->append(v); |
| } |
| |
| static SkScalar quad_error_at(const SkPoint pts[3], SkScalar t, SkScalar u) { |
| SkQuadCoeff quad(pts); |
| SkPoint p0 = to_point(quad.eval(t - 0.5f * u)); |
| SkPoint mid = to_point(quad.eval(t)); |
| SkPoint p1 = to_point(quad.eval(t + 0.5f * u)); |
| if (!p0.isFinite() || !mid.isFinite() || !p1.isFinite()) { |
| return 0; |
| } |
| return SkPointPriv::DistanceToLineSegmentBetweenSqd(mid, p0, p1); |
| } |
| |
| void GrTriangulator::appendQuadraticToContour(const SkPoint pts[3], SkScalar toleranceSqd, |
| VertexList* contour) const { |
| SkQuadCoeff quad(pts); |
| Sk2s aa = quad.fA * quad.fA; |
| SkScalar denom = 2.0f * (aa[0] + aa[1]); |
| Sk2s 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); |
| } |
| } |
| |
| void GrTriangulator::generateCubicPoints(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2, |
| const SkPoint& p3, SkScalar tolSqd, VertexList* contour, |
| int pointsLeft) const { |
| SkScalar d1 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3); |
| SkScalar d2 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3); |
| if (pointsLeft < 2 || (d1 < tolSqd && d2 < tolSqd) || |
| !SkScalarIsFinite(d1) || !SkScalarIsFinite(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); |
| } |
| |
| // Stage 1: convert the input path to a set of linear contours (linked list of Vertices). |
| |
| void GrTriangulator::pathToContours(float tolerance, const SkRect& clipBounds, |
| VertexList* contours, bool* isLinear) const { |
| 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; |
| } |
| } |
| } |
| |
| static inline bool apply_fill_type(SkPathFillType fillType, int winding) { |
| switch (fillType) { |
| case SkPathFillType::kWinding: |
| return winding != 0; |
| case SkPathFillType::kEvenOdd: |
| return (winding & 1) != 0; |
| case SkPathFillType::kInverseWinding: |
| return winding == 1; |
| case SkPathFillType::kInverseEvenOdd: |
| return (winding & 1) == 1; |
| default: |
| SkASSERT(false); |
| return false; |
| } |
| } |
| |
| bool GrTriangulator::applyFillType(int winding) const { |
| return apply_fill_type(fPath.getFillType(), winding); |
| } |
| |
| static inline bool apply_fill_type(SkPathFillType fillType, Poly* poly) { |
| return poly && apply_fill_type(fillType, poly->fWinding); |
| } |
| |
| Edge* GrTriangulator::makeEdge(Vertex* prev, Vertex* next, EdgeType type, |
| const Comparator& c) const { |
| 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 fAlloc->make<Edge>(top, bottom, winding, type); |
| } |
| |
| void EdgeList::insert(Edge* edge, Edge* prev) { |
| TESS_LOG("inserting edge %g -> %g\n", edge->fTop->fID, edge->fBottom->fID); |
| SkASSERT(!this->contains(edge)); |
| Edge* next = prev ? prev->fRight : fHead; |
| this->insert(edge, prev, next); |
| } |
| |
| void GrTriangulator::FindEnclosingEdges(Vertex* v, EdgeList* edges, Edge** left, Edge** right) { |
| 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; |
| } |
| |
| void GrTriangulator::Edge::insertAbove(Vertex* v, const Comparator& c) { |
| if (fTop->fPoint == fBottom->fPoint || |
| c.sweep_lt(fBottom->fPoint, fTop->fPoint)) { |
| return; |
| } |
| TESS_LOG("insert edge (%g -> %g) above vertex %g\n", fTop->fID, fBottom->fID, v->fID); |
| Edge* prev = nullptr; |
| Edge* next; |
| for (next = v->fFirstEdgeAbove; next; next = next->fNextEdgeAbove) { |
| if (next->isRightOf(fTop)) { |
| break; |
| } |
| prev = next; |
| } |
| list_insert<Edge, &Edge::fPrevEdgeAbove, &Edge::fNextEdgeAbove>( |
| this, prev, next, &v->fFirstEdgeAbove, &v->fLastEdgeAbove); |
| } |
| |
| void GrTriangulator::Edge::insertBelow(Vertex* v, const Comparator& c) { |
| if (fTop->fPoint == fBottom->fPoint || |
| c.sweep_lt(fBottom->fPoint, fTop->fPoint)) { |
| return; |
| } |
| TESS_LOG("insert edge (%g -> %g) below vertex %g\n", fTop->fID, fBottom->fID, v->fID); |
| Edge* prev = nullptr; |
| Edge* next; |
| for (next = v->fFirstEdgeBelow; next; next = next->fNextEdgeBelow) { |
| if (next->isRightOf(fBottom)) { |
| break; |
| } |
| prev = next; |
| } |
| list_insert<Edge, &Edge::fPrevEdgeBelow, &Edge::fNextEdgeBelow>( |
| this, prev, next, &v->fFirstEdgeBelow, &v->fLastEdgeBelow); |
| } |
| |
| static void remove_edge_above(Edge* edge) { |
| SkASSERT(edge->fTop && edge->fBottom); |
| TESS_LOG("removing edge (%g -> %g) above vertex %g\n", edge->fTop->fID, edge->fBottom->fID, |
| edge->fBottom->fID); |
| list_remove<Edge, &Edge::fPrevEdgeAbove, &Edge::fNextEdgeAbove>( |
| edge, &edge->fBottom->fFirstEdgeAbove, &edge->fBottom->fLastEdgeAbove); |
| } |
| |
| static void remove_edge_below(Edge* edge) { |
| SkASSERT(edge->fTop && edge->fBottom); |
| TESS_LOG("removing edge (%g -> %g) below vertex %g\n", |
| edge->fTop->fID, edge->fBottom->fID, edge->fTop->fID); |
| list_remove<Edge, &Edge::fPrevEdgeBelow, &Edge::fNextEdgeBelow>( |
| edge, &edge->fTop->fFirstEdgeBelow, &edge->fTop->fLastEdgeBelow); |
| } |
| |
| void GrTriangulator::Edge::disconnect() { |
| remove_edge_above(this); |
| remove_edge_below(this); |
| } |
| |
| static void rewind(EdgeList* activeEdges, Vertex** current, Vertex* dst, const Comparator& c) { |
| if (!current || *current == dst || c.sweep_lt((*current)->fPoint, dst->fPoint)) { |
| return; |
| } |
| Vertex* v = *current; |
| TESS_LOG("rewinding active edges from vertex %g to vertex %g\n", v->fID, dst->fID); |
| while (v != dst) { |
| v = v->fPrev; |
| for (Edge* e = v->fFirstEdgeBelow; e; e = e->fNextEdgeBelow) { |
| activeEdges->remove(e); |
| } |
| Edge* leftEdge = v->fLeftEnclosingEdge; |
| for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) { |
| activeEdges->insert(e, leftEdge); |
| leftEdge = e; |
| Vertex* top = e->fTop; |
| if (c.sweep_lt(top->fPoint, dst->fPoint) && |
| ((top->fLeftEnclosingEdge && !top->fLeftEnclosingEdge->isLeftOf(e->fTop)) || |
| (top->fRightEnclosingEdge && !top->fRightEnclosingEdge->isRightOf(e->fTop)))) { |
| dst = top; |
| } |
| } |
| } |
| *current = v; |
| } |
| |
| static void rewind_if_necessary(Edge* edge, EdgeList* activeEdges, Vertex** current, |
| const Comparator& c) { |
| if (!activeEdges || !current) { |
| return; |
| } |
| Vertex* top = edge->fTop; |
| Vertex* bottom = edge->fBottom; |
| if (edge->fLeft) { |
| Vertex* leftTop = edge->fLeft->fTop; |
| Vertex* leftBottom = edge->fLeft->fBottom; |
| if (c.sweep_lt(leftTop->fPoint, top->fPoint) && !edge->fLeft->isLeftOf(top)) { |
| rewind(activeEdges, current, leftTop, c); |
| } else if (c.sweep_lt(top->fPoint, leftTop->fPoint) && !edge->isRightOf(leftTop)) { |
| rewind(activeEdges, current, top, c); |
| } else if (c.sweep_lt(bottom->fPoint, leftBottom->fPoint) && |
| !edge->fLeft->isLeftOf(bottom)) { |
| rewind(activeEdges, current, leftTop, c); |
| } else if (c.sweep_lt(leftBottom->fPoint, bottom->fPoint) && !edge->isRightOf(leftBottom)) { |
| rewind(activeEdges, current, top, c); |
| } |
| } |
| if (edge->fRight) { |
| Vertex* rightTop = edge->fRight->fTop; |
| Vertex* rightBottom = edge->fRight->fBottom; |
| if (c.sweep_lt(rightTop->fPoint, top->fPoint) && !edge->fRight->isRightOf(top)) { |
| rewind(activeEdges, current, rightTop, c); |
| } else if (c.sweep_lt(top->fPoint, rightTop->fPoint) && !edge->isLeftOf(rightTop)) { |
| rewind(activeEdges, current, top, c); |
| } else if (c.sweep_lt(bottom->fPoint, rightBottom->fPoint) && |
| !edge->fRight->isRightOf(bottom)) { |
| rewind(activeEdges, current, rightTop, c); |
| } else if (c.sweep_lt(rightBottom->fPoint, bottom->fPoint) && |
| !edge->isLeftOf(rightBottom)) { |
| rewind(activeEdges, current, top, c); |
| } |
| } |
| } |
| |
| void GrTriangulator::setTop(Edge* edge, Vertex* v, EdgeList* activeEdges, Vertex** current, |
| const Comparator& c) const { |
| 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); |
| rewind_if_necessary(edge, activeEdges, current, c); |
| this->mergeCollinearEdges(edge, activeEdges, current, c); |
| } |
| |
| void GrTriangulator::setBottom(Edge* edge, Vertex* v, EdgeList* activeEdges, Vertex** current, |
| const Comparator& c) const { |
| 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); |
| rewind_if_necessary(edge, activeEdges, current, c); |
| this->mergeCollinearEdges(edge, activeEdges, current, c); |
| } |
| |
| void GrTriangulator::mergeEdgesAbove(Edge* edge, Edge* other, EdgeList* activeEdges, |
| Vertex** current, const Comparator& c) const { |
| 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); |
| rewind(activeEdges, current, edge->fTop, c); |
| other->fWinding += edge->fWinding; |
| edge->disconnect(); |
| edge->fTop = edge->fBottom = nullptr; |
| } else if (c.sweep_lt(edge->fTop->fPoint, other->fTop->fPoint)) { |
| rewind(activeEdges, current, edge->fTop, c); |
| other->fWinding += edge->fWinding; |
| this->setBottom(edge, other->fTop, activeEdges, current, c); |
| } else { |
| rewind(activeEdges, current, other->fTop, c); |
| edge->fWinding += other->fWinding; |
| this->setBottom(other, edge->fTop, activeEdges, current, c); |
| } |
| } |
| |
| void GrTriangulator::mergeEdgesBelow(Edge* edge, Edge* other, EdgeList* activeEdges, |
| Vertex** current, const Comparator& c) const { |
| 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); |
| rewind(activeEdges, current, edge->fTop, c); |
| other->fWinding += edge->fWinding; |
| edge->disconnect(); |
| edge->fTop = edge->fBottom = nullptr; |
| } else if (c.sweep_lt(edge->fBottom->fPoint, other->fBottom->fPoint)) { |
| rewind(activeEdges, current, other->fTop, c); |
| edge->fWinding += other->fWinding; |
| this->setTop(other, edge->fBottom, activeEdges, current, c); |
| } else { |
| rewind(activeEdges, current, edge->fTop, c); |
| other->fWinding += edge->fWinding; |
| this->setTop(edge, other->fBottom, activeEdges, current, c); |
| } |
| } |
| |
| static bool top_collinear(Edge* left, Edge* right) { |
| if (!left || !right) { |
| return false; |
| } |
| return left->fTop->fPoint == right->fTop->fPoint || |
| !left->isLeftOf(right->fTop) || !right->isRightOf(left->fTop); |
| } |
| |
| static bool bottom_collinear(Edge* left, Edge* right) { |
| if (!left || !right) { |
| return false; |
| } |
| return left->fBottom->fPoint == right->fBottom->fPoint || |
| !left->isLeftOf(right->fBottom) || !right->isRightOf(left->fBottom); |
| } |
| |
| void GrTriangulator::mergeCollinearEdges(Edge* edge, EdgeList* activeEdges, Vertex** current, |
| const Comparator& c) const { |
| for (;;) { |
| if (top_collinear(edge->fPrevEdgeAbove, edge)) { |
| this->mergeEdgesAbove(edge->fPrevEdgeAbove, edge, activeEdges, current, c); |
| } else if (top_collinear(edge, edge->fNextEdgeAbove)) { |
| this->mergeEdgesAbove(edge->fNextEdgeAbove, edge, activeEdges, current, c); |
| } else if (bottom_collinear(edge->fPrevEdgeBelow, edge)) { |
| this->mergeEdgesBelow(edge->fPrevEdgeBelow, edge, activeEdges, current, c); |
| } else if (bottom_collinear(edge, edge->fNextEdgeBelow)) { |
| this->mergeEdgesBelow(edge->fNextEdgeBelow, edge, activeEdges, current, c); |
| } 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)); |
| } |
| |
| bool GrTriangulator::splitEdge(Edge* edge, Vertex* v, EdgeList* activeEdges, Vertex** current, |
| const Comparator& c) const { |
| if (!edge->fTop || !edge->fBottom || v == edge->fTop || v == edge->fBottom) { |
| return false; |
| } |
| 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; |
| if (c.sweep_lt(v->fPoint, edge->fTop->fPoint)) { |
| top = v; |
| bottom = edge->fTop; |
| this->setTop(edge, v, activeEdges, current, c); |
| } else if (c.sweep_lt(edge->fBottom->fPoint, v->fPoint)) { |
| top = edge->fBottom; |
| bottom = v; |
| this->setBottom(edge, v, activeEdges, current, c); |
| } else { |
| top = v; |
| bottom = edge->fBottom; |
| this->setBottom(edge, v, activeEdges, current, c); |
| } |
| Edge* newEdge = fAlloc->make<Edge>(top, bottom, winding, edge->fType); |
| newEdge->insertBelow(top, c); |
| newEdge->insertAbove(bottom, c); |
| this->mergeCollinearEdges(newEdge, activeEdges, current, c); |
| return true; |
| } |
| |
| bool GrTriangulator::intersectEdgePair(Edge* left, Edge* right, EdgeList* activeEdges, |
| Vertex** current, const Comparator& c) const { |
| if (!left->fTop || !left->fBottom || !right->fTop || !right->fBottom) { |
| return false; |
| } |
| if (left->fTop == right->fTop || left->fBottom == right->fBottom) { |
| return false; |
| } |
| if (c.sweep_lt(left->fTop->fPoint, right->fTop->fPoint)) { |
| if (!left->isLeftOf(right->fTop)) { |
| rewind(activeEdges, current, right->fTop, c); |
| return this->splitEdge(left, right->fTop, activeEdges, current, c); |
| } |
| } else { |
| if (!right->isRightOf(left->fTop)) { |
| rewind(activeEdges, current, left->fTop, c); |
| return this->splitEdge(right, left->fTop, activeEdges, current, c); |
| } |
| } |
| if (c.sweep_lt(right->fBottom->fPoint, left->fBottom->fPoint)) { |
| if (!left->isLeftOf(right->fBottom)) { |
| rewind(activeEdges, current, right->fBottom, c); |
| return this->splitEdge(left, right->fBottom, activeEdges, current, c); |
| } |
| } else { |
| if (!right->isRightOf(left->fBottom)) { |
| rewind(activeEdges, current, left->fBottom, c); |
| return this->splitEdge(right, left->fBottom, activeEdges, current, c); |
| } |
| } |
| return false; |
| } |
| |
| Edge* GrTriangulator::makeConnectingEdge(Vertex* prev, Vertex* next, EdgeType type, |
| const Comparator& c, int windingScale) const { |
| 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; |
| } |
| |
| void GrTriangulator::mergeVertices(Vertex* src, Vertex* dst, VertexList* mesh, |
| const Comparator& c) const { |
| 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) { |
| this->setBottom(edge, dst, nullptr, nullptr, c); |
| } |
| while (Edge* edge = src->fFirstEdgeBelow) { |
| this->setTop(edge, dst, nullptr, nullptr, c); |
| } |
| mesh->remove(src); |
| dst->fSynthetic = true; |
| } |
| |
| Vertex* GrTriangulator::makeSortedVertex(const SkPoint& p, uint8_t alpha, VertexList* mesh, |
| Vertex* reference, const Comparator& c) const { |
| 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; |
| } |
| |
| // If an edge's top and bottom points differ only by 1/2 machine epsilon in the primary |
| // sort criterion, it may not be possible to split correctly, since there is no point which is |
| // below the top and above the bottom. This function detects that case. |
| static bool nearly_flat(const Comparator& c, Edge* edge) { |
| SkPoint diff = edge->fBottom->fPoint - edge->fTop->fPoint; |
| float primaryDiff = c.fDirection == Comparator::Direction::kHorizontal ? diff.fX : diff.fY; |
| return fabs(primaryDiff) <= std::numeric_limits<float>::epsilon() && primaryDiff != 0.0f; |
| } |
| |
| static SkPoint clamp(SkPoint p, SkPoint min, SkPoint max, const Comparator& c) { |
| if (c.sweep_lt(p, min)) { |
| return min; |
| } else if (c.sweep_lt(max, p)) { |
| return max; |
| } else { |
| return p; |
| } |
| } |
| |
| void GrTriangulator::computeBisector(Edge* edge1, Edge* edge2, Vertex* v) const { |
| 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); |
| } |
| } |
| |
| bool GrTriangulator::checkForIntersection(Edge* left, Edge* right, EdgeList* activeEdges, |
| Vertex** current, VertexList* mesh, |
| const Comparator& c) const { |
| if (!left || !right) { |
| return false; |
| } |
| SkPoint p; |
| uint8_t alpha; |
| 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; |
| } |
| bool leftFlat = nearly_flat(c, left); |
| bool rightFlat = nearly_flat(c, right); |
| if (leftFlat && rightFlat) { |
| return false; |
| } |
| if (!leftFlat) { |
| p = clamp(p, left->fTop->fPoint, left->fBottom->fPoint, c); |
| } |
| if (!rightFlat) { |
| 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); |
| } |
| } |
| rewind(activeEdges, current, top ? top : v, c); |
| this->splitEdge(left, v, activeEdges, current, c); |
| this->splitEdge(right, v, activeEdges, current, c); |
| v->fAlpha = std::max(v->fAlpha, alpha); |
| return true; |
| } |
| return this->intersectEdgePair(left, right, activeEdges, current, c); |
| } |
| |
| void GrTriangulator::sanitizeContours(VertexList* contours, int contourCnt) const { |
| 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; |
| } |
| } |
| } |
| |
| bool GrTriangulator::mergeCoincidentVertices(VertexList* mesh, const Comparator& c) const { |
| 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; |
| } |
| |
| // Stage 2: convert the contours to a mesh of edges connecting the vertices. |
| |
| void GrTriangulator::buildEdges(VertexList* contours, int contourCnt, VertexList* mesh, |
| const Comparator& c) const { |
| 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; |
| } |
| } |
| } |
| |
| template <CompareFunc sweep_lt> |
| static void sorted_merge(VertexList* front, VertexList* back, VertexList* result) { |
| Vertex* a = front->fHead; |
| Vertex* b = back->fHead; |
| while (a && b) { |
| if (sweep_lt(a->fPoint, b->fPoint)) { |
| front->remove(a); |
| result->append(a); |
| a = front->fHead; |
| } else { |
| back->remove(b); |
| result->append(b); |
| b = back->fHead; |
| } |
| } |
| result->append(*front); |
| result->append(*back); |
| } |
| |
| void GrTriangulator::SortedMerge(VertexList* front, VertexList* back, VertexList* result, |
| const Comparator& c) { |
| 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 |
| } |
| |
| // Stage 3: sort the vertices by increasing sweep direction. |
| |
| template <CompareFunc sweep_lt> |
| static void merge_sort(VertexList* vertices) { |
| Vertex* slow = vertices->fHead; |
| if (!slow) { |
| return; |
| } |
| Vertex* fast = slow->fNext; |
| if (!fast) { |
| return; |
| } |
| do { |
| fast = fast->fNext; |
| if (fast) { |
| fast = fast->fNext; |
| slow = slow->fNext; |
| } |
| } while (fast); |
| VertexList front(vertices->fHead, slow); |
| VertexList back(slow->fNext, vertices->fTail); |
| front.fTail->fNext = back.fHead->fPrev = nullptr; |
| |
| merge_sort<sweep_lt>(&front); |
| merge_sort<sweep_lt>(&back); |
| |
| vertices->fHead = vertices->fTail = nullptr; |
| sorted_merge<sweep_lt>(&front, &back, vertices); |
| } |
| |
| #if TRIANGULATOR_LOGGING |
| void VertexList::dump() const { |
| for (Vertex* v = fHead; v; v = v->fNext) { |
| TESS_LOG("vertex %g (%g, %g) alpha %d", v->fID, v->fPoint.fX, v->fPoint.fY, v->fAlpha); |
| if (Vertex* p = v->fPartner) { |
| TESS_LOG(", partner %g (%g, %g) alpha %d\n", |
| p->fID, p->fPoint.fX, p->fPoint.fY, p->fAlpha); |
| } else { |
| TESS_LOG(", null partner\n"); |
| } |
| for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) { |
| TESS_LOG(" edge %g -> %g, winding %d\n", e->fTop->fID, e->fBottom->fID, e->fWinding); |
| } |
| for (Edge* e = v->fFirstEdgeBelow; e; e = e->fNextEdgeBelow) { |
| TESS_LOG(" edge %g -> %g, winding %d\n", e->fTop->fID, e->fBottom->fID, e->fWinding); |
| } |
| } |
| } |
| #endif |
| |
| #ifdef SK_DEBUG |
| static void validate_edge_pair(Edge* left, Edge* right, const Comparator& c) { |
| if (!left || !right) { |
| return; |
| } |
| if (left->fTop == right->fTop) { |
| SkASSERT(left->isLeftOf(right->fBottom)); |
| SkASSERT(right->isRightOf(left->fBottom)); |
| } else if (c.sweep_lt(left->fTop->fPoint, right->fTop->fPoint)) { |
| SkASSERT(left->isLeftOf(right->fTop)); |
| } else { |
| SkASSERT(right->isRightOf(left->fTop)); |
| } |
| if (left->fBottom == right->fBottom) { |
| SkASSERT(left->isLeftOf(right->fTop)); |
| SkASSERT(right->isRightOf(left->fTop)); |
| } else if (c.sweep_lt(right->fBottom->fPoint, left->fBottom->fPoint)) { |
| SkASSERT(left->isLeftOf(right->fBottom)); |
| } else { |
| SkASSERT(right->isRightOf(left->fBottom)); |
| } |
| } |
| |
| static void validate_edge_list(EdgeList* edges, const Comparator& c) { |
| Edge* left = edges->fHead; |
| if (!left) { |
| return; |
| } |
| for (Edge* right = left->fRight; right; right = right->fRight) { |
| validate_edge_pair(left, right, c); |
| left = right; |
| } |
| } |
| #endif |
| |
| // Stage 4: Simplify the mesh by inserting new vertices at intersecting edges. |
| |
| GrTriangulator::SimplifyResult GrTriangulator::simplify(VertexList* mesh, |
| const Comparator& c) const { |
| TESS_LOG("simplifying complex polygons\n"); |
| EdgeList activeEdges; |
| auto result = SimplifyResult::kAlreadySimple; |
| for (Vertex* v = mesh->fHead; v != nullptr; v = v->fNext) { |
| if (!v->isConnected()) { |
| continue; |
| } |
| 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) { |
| if (this->checkForIntersection( |
| leftEnclosingEdge, edge, &activeEdges, &v, mesh, c) || |
| this->checkForIntersection( |
| edge, rightEnclosingEdge, &activeEdges, &v, mesh, c)) { |
| result = SimplifyResult::kFoundSelfIntersection; |
| restartChecks = true; |
| break; |
| } |
| } |
| } else { |
| if (this->checkForIntersection(leftEnclosingEdge, rightEnclosingEdge, &activeEdges, |
| &v, mesh, c)) { |
| result = SimplifyResult::kFoundSelfIntersection; |
| restartChecks = true; |
| } |
| |
| } |
| } while (restartChecks); |
| #ifdef SK_DEBUG |
| validate_edge_list(&activeEdges, c); |
| #endif |
| for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) { |
| activeEdges.remove(e); |
| } |
| 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; |
| } |
| |
| // Stage 5: Tessellate the simplified mesh into monotone polygons. |
| |
| Poly* GrTriangulator::tessellate(const VertexList& vertices, const Comparator&) const { |
| 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, fAlloc); |
| } |
| if (rightPoly) { |
| rightPoly = rightPoly->addEdge(v->fLastEdgeAbove, kLeft_Side, fAlloc); |
| } |
| 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, fAlloc); |
| } |
| if (rightEdge->fLeftPoly && rightEdge->fLeftPoly != e->fRightPoly) { |
| rightEdge->fLeftPoly->addEdge(e, kRight_Side, fAlloc); |
| } |
| } |
| 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 = fAlloc->make<Edge>(leftPoly->lastVertex(), v, 1, |
| EdgeType::kInner); |
| leftPoly = leftPoly->addEdge(join, kRight_Side, fAlloc); |
| rightPoly = rightPoly->addEdge(join, kLeft_Side, fAlloc); |
| } |
| } |
| 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; |
| } |
| |
| // This is a driver function that calls stages 2-5 in turn. |
| |
| void GrTriangulator::contoursToMesh(VertexList* contours, int contourCnt, VertexList* mesh, |
| const Comparator& c) const { |
| #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); |
| } |
| |
| void GrTriangulator::SortMesh(VertexList* vertices, const Comparator& c) { |
| 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 |
| } |
| |
| Poly* GrTriangulator::contoursToPolys(VertexList* contours, int contourCnt) const { |
| 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); |
| this->simplify(&mesh, c); |
| TESS_LOG("\nsimplified mesh:\n"); |
| DUMP_MESH(mesh); |
| return this->tessellate(mesh, c); |
| } |
| |
| // Stage 6: Triangulate the monotone polygons into a vertex buffer. |
| void* GrTriangulator::polysToTriangles(Poly* polys, void* data, |
| SkPathFillType overrideFillType) const { |
| for (Poly* poly = polys; poly; poly = poly->fNext) { |
| if (apply_fill_type(overrideFillType, poly)) { |
| data = this->emitPoly(poly, data); |
| } |
| } |
| return data; |
| } |
| |
| static int get_contour_count(const SkPath& path, SkScalar tolerance) { |
| // We could theoretically be more aggressive about not counting empty contours, but we need to |
| // actually match the exact number of contour linked lists the tessellator will create later on. |
| int contourCnt = 1; |
| bool hasPoints = false; |
| |
| SkPath::Iter iter(path, false); |
| SkPath::Verb verb; |
| SkPoint pts[4]; |
| bool first = true; |
| while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { |
| switch (verb) { |
| case SkPath::kMove_Verb: |
| if (!first) { |
| ++contourCnt; |
| } |
| [[fallthrough]]; |
| case SkPath::kLine_Verb: |
| case SkPath::kConic_Verb: |
| case SkPath::kQuad_Verb: |
| case SkPath::kCubic_Verb: |
| hasPoints = true; |
| break; |
| default: |
| break; |
| } |
| first = false; |
| } |
| if (!hasPoints) { |
| return 0; |
| } |
| return contourCnt; |
| } |
| |
| Poly* GrTriangulator::pathToPolys(float tolerance, const SkRect& clipBounds, bool* isLinear) const { |
| int contourCnt = get_contour_count(fPath, tolerance); |
| if (contourCnt <= 0) { |
| *isLinear = true; |
| return nullptr; |
| } |
| |
| 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); |
| } |
| |
| int64_t GrTriangulator::CountPoints(Poly* polys, SkPathFillType overrideFillType) { |
| 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; |
| } |
| |
| // Stage 6: Triangulate the monotone polygons into a vertex buffer. |
| |
| int GrTriangulator::polysToTriangles(Poly* polys, GrEagerVertexAllocator* vertexAllocator) const { |
| 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); |
| } |
| void* verts = vertexAllocator->lock(vertexStride, count); |
| if (!verts) { |
| SkDebugf("Could not allocate vertices\n"); |
| return 0; |
| } |
| |
| TESS_LOG("emitting %d verts\n", count); |
| void* end = this->polysToTriangles(polys, verts, fPath.getFillType()); |
| |
| int actualCount = static_cast<int>((static_cast<uint8_t*>(end) - static_cast<uint8_t*>(verts)) |
| / vertexStride); |
| SkASSERT(actualCount <= count); |
| vertexAllocator->unlock(actualCount); |
| return actualCount; |
| } |