GrTriangulator.cpp File Reference

#include "src/gpu/ganesh/geometry/GrTriangulator.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkRect.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTPin.h"
#include "src/base/SkVx.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkPointPriv.h"
#include "src/gpu/BufferWriter.h"
#include "src/gpu/ganesh/GrColor.h"
#include "src/gpu/ganesh/GrEagerVertexAllocator.h"
#include "src/gpu/ganesh/geometry/GrPathUtils.h"
#include <algorithm>
#include <cstddef>
#include <limits>
#include <memory>
#include <tuple>
#include <utility>

Go to the source code of this file.

Macros
#define	TESS_LOG(...)
#define	DUMP_MESH(M)

Typedefs
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
typedef bool(*	CompareFunc) (const SkPoint &a, const SkPoint &b)

Functions
template<class T , T *T::* Prev, T *T::* Next>
static void	list_insert (T *t, T *prev, T *next, T **head, T **tail)
template<class T , T *T::* Prev, T *T::* Next>
static void	list_remove (T *t, T **head, T **tail)
static bool	sweep_lt_horiz (const SkPoint &a, const SkPoint &b)
static bool	sweep_lt_vert (const SkPoint &a, const SkPoint &b)
static skgpu::VertexWriter	emit_vertex (Vertex *v, bool emitCoverage, skgpu::VertexWriter data)
static skgpu::VertexWriter	emit_triangle (Vertex *v0, Vertex *v1, Vertex *v2, bool emitCoverage, skgpu::VertexWriter data)
static void	round (SkPoint *p)
static SkScalar	double_to_clamped_scalar (double d)
static bool	edge_line_needs_recursion (const SkPoint &p0, const SkPoint &p1)
static bool	recursive_edge_intersect (const Line &u, SkPoint u0, SkPoint u1, const Line &v, SkPoint v0, SkPoint v1, SkPoint *p, double *s, double *t)
static bool	coincident (const SkPoint &a, const SkPoint &b)
static SkScalar	quad_error_at (const SkPoint pts[3], SkScalar t, SkScalar u)
static bool	apply_fill_type (SkPathFillType fillType, int winding)
static bool	apply_fill_type (SkPathFillType fillType, Poly *poly)
static void	remove_edge_above (Edge *edge)
static void	remove_edge_below (Edge *edge)
static bool	rewind (EdgeList *activeEdges, Vertex **current, Vertex *dst, const Comparator &c)
static bool	rewind_if_necessary (Edge *edge, EdgeList *activeEdges, Vertex **current, const Comparator &c)
static bool	top_collinear (Edge *left, Edge *right)
static bool	bottom_collinear (Edge *left, Edge *right)
static SkPoint	clamp (SkPoint p, SkPoint min, SkPoint max, const Comparator &c)
template<CompareFunc sweep_lt>
static void	sorted_merge (VertexList *front, VertexList *back, VertexList *result)
template<CompareFunc sweep_lt>
static void	merge_sort (VertexList *vertices)
static int	get_contour_count (const SkPath &path, SkScalar tolerance)

Macro Definition Documentation

DUMP_MESH

#define DUMP_MESH

(

M

)

Definition at line 38 of file GrTriangulator.cpp.

TESS_LOG

#define TESS_LOG

(

...

)

Definition at line 37 of file GrTriangulator.cpp.

Typedef Documentation

Comparator

using Comparator = GrTriangulator::Comparator

Definition at line 49 of file GrTriangulator.cpp.

CompareFunc

typedef bool(* CompareFunc) (const SkPoint &a, const SkPoint &b)

Definition at line 82 of file GrTriangulator.cpp.

Edge

using Edge = GrTriangulator::Edge

Definition at line 45 of file GrTriangulator.cpp.

EdgeList

using EdgeList = GrTriangulator::EdgeList

Definition at line 46 of file GrTriangulator.cpp.

EdgeType

using EdgeType = GrTriangulator::EdgeType

Definition at line 41 of file GrTriangulator.cpp.

Line

using Line = GrTriangulator::Line

Definition at line 44 of file GrTriangulator.cpp.

MonotonePoly

using MonotonePoly = GrTriangulator::MonotonePoly

Definition at line 48 of file GrTriangulator.cpp.

Poly

using Poly = GrTriangulator::Poly

Definition at line 47 of file GrTriangulator.cpp.

Vertex

using Vertex = GrTriangulator::Vertex

Definition at line 42 of file GrTriangulator.cpp.

VertexList

using VertexList = GrTriangulator::VertexList

Definition at line 43 of file GrTriangulator.cpp.

Function Documentation

apply_fill_type() [1/2]

static bool apply_fill_type ( SkPathFillType  fillType, int  winding  )

inlinestatic

Definition at line 614 of file GrTriangulator.cpp.

                                                                         {
    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;
    }
}

apply_fill_type() [2/2]

static bool apply_fill_type ( SkPathFillType  fillType, Poly *  poly  )

inlinestatic

Definition at line 634 of file GrTriangulator.cpp.

                                                                        {
    return poly && apply_fill_type(fillType, poly->fWinding);
}

bottom_collinear()

static bool bottom_collinear ( Edge *  left, Edge *  right  )

static

Definition at line 949 of file GrTriangulator.cpp.

                                                      {
    if (!left || !right) {
        return false;
    }
    return left->fBottom->fPoint == right->fBottom->fPoint ||
           !left->isLeftOf(*right->fBottom) || !right->isRightOf(*left->fBottom);
}

clamp()

static SkPoint clamp ( SkPoint  p, SkPoint  min, SkPoint  max, const Comparator &  c  )

static

Definition at line 1152 of file GrTriangulator.cpp.

                                                                               {
    if (c.fDirection == Comparator::Direction::kHorizontal) {
        // With horizontal sorting, we know min.x <= max.x, but there's no relation between
        // Y components unless min.x == max.x.
        return {SkTPin(p.fX, min.fX, max.fX),
                min.fY < max.fY ? SkTPin(p.fY, min.fY, max.fY)
                                : SkTPin(p.fY, max.fY, min.fY)};
    } else {
        // And with vertical sorting, we know Y's relation but not necessarily X's.
        return {min.fX < max.fX ? SkTPin(p.fX, min.fX, max.fX)
                                : SkTPin(p.fX, max.fX, min.fX),
                SkTPin(p.fY, min.fY, max.fY)};
    }
}

coincident()

static bool coincident ( const SkPoint &  a, const SkPoint &  b  )

static

Definition at line 464 of file GrTriangulator.cpp.

                                                           {
    return a == b;
}

double_to_clamped_scalar()

static SkScalar double_to_clamped_scalar ( double  d )

inlinestatic

Definition at line 143 of file GrTriangulator.cpp.

                                                          {
    // 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)));
}

edge_line_needs_recursion()

static bool edge_line_needs_recursion ( const SkPoint &  p0, const SkPoint &  p1  )

static

Definition at line 170 of file GrTriangulator.cpp.

                                                                            {
    // ilogbf(0) returns an implementation-defined constant, but we are choosing to saturate
    // negative exponents to 0 for comparisons sake. We're only trying to recurse on lines with
    // very large coordinates.
    int expDiffX = std::abs((std::abs(p0.fX) < 1.f ? 0 : std::ilogbf(p0.fX)) -
                            (std::abs(p1.fX) < 1.f ? 0 : std::ilogbf(p1.fX)));
    int expDiffY = std::abs((std::abs(p0.fY) < 1.f ? 0 : std::ilogbf(p0.fY)) -
                            (std::abs(p1.fY) < 1.f ? 0 : std::ilogbf(p1.fY)));
    // Differ by more than 2^20, or roughly a factor of one million.
    return expDiffX > 20 || expDiffY > 20;
}

emit_triangle()

static skgpu::VertexWriter emit_triangle ( Vertex *  v0, Vertex *  v1, Vertex *  v2, bool  emitCoverage, skgpu::VertexWriter  data  )

static

Definition at line 108 of file GrTriangulator.cpp.

                                                                                    {
    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 TRIANGULATOR_WIREFRAME
    data = emit_vertex(v0, emitCoverage, std::move(data));
    data = emit_vertex(v1, emitCoverage, std::move(data));
    data = emit_vertex(v1, emitCoverage, std::move(data));
    data = emit_vertex(v2, emitCoverage, std::move(data));
    data = emit_vertex(v2, emitCoverage, std::move(data));
    data = emit_vertex(v0, emitCoverage, std::move(data));
#else
    data = emit_vertex(v0, emitCoverage, std::move(data));
    data = emit_vertex(v1, emitCoverage, std::move(data));
    data = emit_vertex(v2, emitCoverage, std::move(data));
#endif
    return data;
}

emit_vertex()

static skgpu::VertexWriter emit_vertex ( Vertex *  v, bool  emitCoverage, skgpu::VertexWriter  data  )

inlinestatic

Definition at line 96 of file GrTriangulator.cpp.

                                                                      {
    data << v->fPoint;
 
    if (emitCoverage) {
        data << GrNormalizeByteToFloat(v->fAlpha);
    }
 
    return data;
}

get_contour_count()

static int get_contour_count ( const SkPath &  path, SkScalar  tolerance  )

static

Definition at line 1708 of file GrTriangulator.cpp.

                                                                     {
    // 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;
}

list_insert()

template<class T , T *T::* Prev, T *T::* Next>

static void list_insert ( T *  t, T *  prev, T *  next, T **  head, T **  tail  )

static

Definition at line 52 of file GrTriangulator.cpp.

                                                                    {
    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;
    }
}

list_remove()

template<class T , T *T::* Prev, T *T::* Next>

static void list_remove ( T *  t, T **  head, T **  tail  )

static

Definition at line 68 of file GrTriangulator.cpp.

                                                  {
    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;
}

merge_sort()

template<CompareFunc sweep_lt>

static void merge_sort ( VertexList *  vertices )

static

Definition at line 1354 of file GrTriangulator.cpp.

                                             {
    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);
}

quad_error_at()

static SkScalar quad_error_at ( const SkPoint  pts[3], SkScalar  t, SkScalar  u  )

static

Definition at line 484 of file GrTriangulator.cpp.

                                                                            {
    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);
}

recursive_edge_intersect()

static bool recursive_edge_intersect ( const Line &  u, SkPoint  u0, SkPoint  u1, const Line &  v, SkPoint  v0, SkPoint  v1, SkPoint *  p, double *  s, double *  t  )

static

Definition at line 182 of file GrTriangulator.cpp.

                                                                       {
    // First check if the bounding boxes of [u0,u1] intersects [v0,v1]. If they do not, then the
    // two line segments cannot intersect in their domain (even if the lines themselves might).
    // - don't use SkRect::intersect since the vertices aren't sorted and horiz/vertical lines
    //   appear as empty rects, which then never "intersect" according to SkRect.
    if (std::min(u0.fX, u1.fX) > std::max(v0.fX, v1.fX) ||
        std::max(u0.fX, u1.fX) < std::min(v0.fX, v1.fX) ||
        std::min(u0.fY, u1.fY) > std::max(v0.fY, v1.fY) ||
        std::max(u0.fY, u1.fY) < std::min(v0.fY, v1.fY)) {
        return false;
    }
 
    // Compute intersection based on current segment vertices; if an intersection is found but the
    // vertices differ too much in magnitude, we recurse using the midpoint of the segment to
    // reject false positives. We don't currently try to avoid false negatives (e.g. large magnitude
    // line reports no intersection but there is one).
    double denom = u.fA * v.fB - u.fB * v.fA;
    if (denom == 0.0) {
        return false;
    }
    double dx = static_cast<double>(v0.fX) - u0.fX;
    double dy = static_cast<double>(v0.fY) - u0.fY;
    double sNumer = dy * v.fB + dx * v.fA;
    double tNumer = dy * u.fB + dx * u.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;
    }
 
    *s = sNumer / denom;
    *t = tNumer / denom;
    SkASSERT(*s >= 0.0 && *s <= 1.0 && *t >= 0.0 && *t <= 1.0);
 
    const bool uNeedsSplit = edge_line_needs_recursion(u0, u1);
    const bool vNeedsSplit = edge_line_needs_recursion(v0, v1);
    if (!uNeedsSplit && !vNeedsSplit) {
        p->fX = double_to_clamped_scalar(u0.fX - (*s) * u.fB);
        p->fY = double_to_clamped_scalar(u0.fY + (*s) * u.fA);
        return true;
    } else {
        double sScale = 1.0, sShift = 0.0;
        double tScale = 1.0, tShift = 0.0;
 
        if (uNeedsSplit) {
            SkPoint uM = {(float) (0.5 * u0.fX + 0.5 * u1.fX),
                          (float) (0.5 * u0.fY + 0.5 * u1.fY)};
            sScale = 0.5;
            if (*s >= 0.5) {
                u0 = uM;
                sShift = 0.5;
            } else {
                u1 = uM;
            }
        }
        if (vNeedsSplit) {
            SkPoint vM = {(float) (0.5 * v0.fX + 0.5 * v1.fX),
                          (float) (0.5 * v0.fY + 0.5 * v1.fY)};
            tScale = 0.5;
            if (*t >= 0.5) {
                v0 = vM;
                tShift = 0.5;
            } else {
                v1 = vM;
            }
        }
 
        // Just recompute both lines, even if only one was split; we're already in a slow path.
        if (recursive_edge_intersect(Line(u0, u1), u0, u1, Line(v0, v1), v0, v1, p, s, t)) {
            // Adjust s and t back to full range
            *s = sScale * (*s) + sShift;
            *t = tScale * (*t) + tShift;
            return true;
        } else {
            // False positive
            return false;
        }
    }
}

remove_edge_above()

static void remove_edge_above ( Edge *  edge )

static

Definition at line 724 of file GrTriangulator.cpp.

                                          {
    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);
}

remove_edge_below()

static void remove_edge_below ( Edge *  edge )

static

Definition at line 732 of file GrTriangulator.cpp.

                                          {
    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);
}

rewind()

static bool rewind ( EdgeList *  activeEdges, Vertex **  current, Vertex *  dst, const Comparator &  c  )

static

Definition at line 745 of file GrTriangulator.cpp.

                                                                                              {
    if (!current || *current == dst || c.sweep_lt((*current)->fPoint, dst->fPoint)) {
        return true;
    }
    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) {
            if (!activeEdges->remove(e)) {
                return false;
            }
        }
        Edge* leftEdge = v->fLeftEnclosingEdge;
        for (Edge* e = v->fFirstEdgeAbove; e; e = e->fNextEdgeAbove) {
            if (!activeEdges->insert(e, leftEdge)) {
                return false;
            }
            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;
    return true;
}

rewind_if_necessary()

static bool rewind_if_necessary ( Edge *  edge, EdgeList *  activeEdges, Vertex **  current, const Comparator &  c  )

static

Definition at line 776 of file GrTriangulator.cpp.

                                                     {
    if (!activeEdges || !current) {
        return true;
    }
    if (!edge) {
        return false;
    }
    Vertex* top = edge->fTop;
    Vertex* bottom = edge->fBottom;
    if (edge->fLeft) {
        Vertex* leftTop = edge->fLeft->fTop;
        Vertex* leftBottom = edge->fLeft->fBottom;
        if (leftTop && leftBottom) {
            if (c.sweep_lt(leftTop->fPoint, top->fPoint) && !edge->fLeft->isLeftOf(*top)) {
                if (!rewind(activeEdges, current, leftTop, c)) {
                    return false;
                }
            } else if (c.sweep_lt(top->fPoint, leftTop->fPoint) && !edge->isRightOf(*leftTop)) {
                if (!rewind(activeEdges, current, top, c)) {
                    return false;
                }
            } else if (c.sweep_lt(bottom->fPoint, leftBottom->fPoint) &&
                       !edge->fLeft->isLeftOf(*bottom)) {
                if (!rewind(activeEdges, current, leftTop, c)) {
                    return false;
                }
            } else if (c.sweep_lt(leftBottom->fPoint, bottom->fPoint) &&
                       !edge->isRightOf(*leftBottom)) {
                if (!rewind(activeEdges, current, top, c)) {
                    return false;
                }
            }
        }
    }
    if (edge->fRight) {
        Vertex* rightTop = edge->fRight->fTop;
        Vertex* rightBottom = edge->fRight->fBottom;
        if (rightTop && rightBottom) {
            if (c.sweep_lt(rightTop->fPoint, top->fPoint) && !edge->fRight->isRightOf(*top)) {
                if (!rewind(activeEdges, current, rightTop, c)) {
                    return false;
                }
            } else if (c.sweep_lt(top->fPoint, rightTop->fPoint) && !edge->isLeftOf(*rightTop)) {
                if (!rewind(activeEdges, current, top, c)) {
                    return false;
                }
            } else if (c.sweep_lt(bottom->fPoint, rightBottom->fPoint) &&
                       !edge->fRight->isRightOf(*bottom)) {
                if (!rewind(activeEdges, current, rightTop, c)) {
                    return false;
                }
            } else if (c.sweep_lt(rightBottom->fPoint, bottom->fPoint) &&
                       !edge->isLeftOf(*rightBottom)) {
                if (!rewind(activeEdges, current, top, c)) {
                    return false;
                }
            }
        }
    }
    return true;
}

round()

static void round ( SkPoint *  p )

inlinestatic

Definition at line 138 of file GrTriangulator.cpp.

                                     {
    p->fX = SkScalarRoundToScalar(p->fX * 4.0f) * 0.25f;
    p->fY = SkScalarRoundToScalar(p->fY * 4.0f) * 0.25f;
}

sorted_merge()

template<CompareFunc sweep_lt>

static void sorted_merge ( VertexList *  front, VertexList *  back, VertexList *  result  )

static

Definition at line 1318 of file GrTriangulator.cpp.

                                                                                  {
    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);
}

sweep_lt_horiz()

static bool sweep_lt_horiz ( const SkPoint &  a, const SkPoint &  b  )

static

Definition at line 84 of file GrTriangulator.cpp.

                                                               {
    return a.fX < b.fX || (a.fX == b.fX && a.fY > b.fY);
}

sweep_lt_vert()

static bool sweep_lt_vert ( const SkPoint &  a, const SkPoint &  b  )

static

Definition at line 88 of file GrTriangulator.cpp.

                                                              {
    return a.fY < b.fY || (a.fY == b.fY && a.fX < b.fX);
}

top_collinear()

static bool top_collinear ( Edge *  left, Edge *  right  )

static

Definition at line 941 of file GrTriangulator.cpp.

                                                   {
    if (!left || !right) {
        return false;
    }
    return left->fTop->fPoint == right->fTop->fPoint ||
           !left->isLeftOf(*right->fTop) || !right->isRightOf(*left->fTop);
}