GrAATriangulator Class Reference

#include <GrAATriangulator.h>

Inheritance diagram for GrAATriangulator:

Classes
struct	Event
struct	EventComparator
struct	EventList
struct	SSEdge

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

Private Member Functions
std::tuple< Poly *, bool >	tessellate (const VertexList &mesh, const Comparator &) override

Detailed Description

Definition at line 27 of file GrAATriangulator.h.

Member Function Documentation

PathToAATriangles()

static int GrAATriangulator::PathToAATriangles ( const SkPath &  path, SkScalar  tolerance, const SkRect &  clipBounds, GrEagerVertexAllocator *  vertexAllocator  )

inlinestatic

Definition at line 29 of file GrAATriangulator.h.

                                                                          {
        SkArenaAlloc alloc(kArenaDefaultChunkSize);
        GrAATriangulator aaTriangulator(path, &alloc);
        aaTriangulator.fRoundVerticesToQuarterPixel = true;
        aaTriangulator.fEmitCoverage = true;
        bool isLinear;
        auto [ polys, success ] = aaTriangulator.pathToPolys(tolerance, clipBounds, &isLinear);
        if (!success) {
            return 0;
        }
        return aaTriangulator.polysToAATriangles(polys, vertexAllocator);
    }

tessellate()

std::tuple< Poly *, bool > GrAATriangulator::tessellate ( const VertexList &  mesh, const Comparator &  c  )

overrideprivatevirtual

Reimplemented from GrTriangulator.

Definition at line 627 of file GrAATriangulator.cpp.

                                                                                              {
    VertexList innerMesh;
    this->extractBoundaries(mesh, &innerMesh, c);
    SortMesh(&innerMesh, c);
    SortMesh(&fOuterMesh, c);
    this->mergeCoincidentVertices(&innerMesh, c);
    bool was_complex = this->mergeCoincidentVertices(&fOuterMesh, c);
    auto result = this->simplify(&innerMesh, c);
    if (result == SimplifyResult::kFailed) {
        return { nullptr, false };
    }
    was_complex = (SimplifyResult::kFoundSelfIntersection == result) || was_complex;
    result = this->simplify(&fOuterMesh, c);
    if (result == SimplifyResult::kFailed) {
        return { nullptr, false };
    }
    was_complex = (SimplifyResult::kFoundSelfIntersection == result) || was_complex;
    TESS_LOG("\ninner mesh before:\n");
    DUMP_MESH(innerMesh);
    TESS_LOG("\nouter mesh before:\n");
    DUMP_MESH(fOuterMesh);
    EventComparator eventLT(EventComparator::Op::kLessThan);
    EventComparator eventGT(EventComparator::Op::kGreaterThan);
    was_complex = this->collapseOverlapRegions(&innerMesh, c, eventLT) || was_complex;
    was_complex = this->collapseOverlapRegions(&fOuterMesh, c, eventGT) || was_complex;
    if (was_complex) {
        TESS_LOG("found complex mesh; taking slow path\n");
        VertexList aaMesh;
        TESS_LOG("\ninner mesh after:\n");
        DUMP_MESH(innerMesh);
        TESS_LOG("\nouter mesh after:\n");
        DUMP_MESH(fOuterMesh);
        this->connectPartners(&fOuterMesh, c);
        this->connectPartners(&innerMesh, c);
        SortedMerge(&innerMesh, &fOuterMesh, &aaMesh, c);
        TESS_LOG("\nmerged mesh:\n");
        DUMP_MESH(aaMesh);
        this->mergeCoincidentVertices(&aaMesh, c);
        result = this->simplify(&aaMesh, c);
        if (result == SimplifyResult::kFailed) {
            return { nullptr, false };
        }
        TESS_LOG("combined and simplified mesh:\n");
        DUMP_MESH(aaMesh);
        fOuterMesh.fHead = fOuterMesh.fTail = nullptr;
        return this->GrTriangulator::tessellate(aaMesh, c);
    } else {
        TESS_LOG("no complex polygons; taking fast path\n");
        return this->GrTriangulator::tessellate(innerMesh, c);
    }
}

---

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

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