GrAATriangulator.cpp File Reference

#include "src/gpu/ganesh/geometry/GrAATriangulator.h"
#include "include/core/SkPathTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMath.h"
#include "src/gpu/BufferWriter.h"
#include "src/gpu/ganesh/GrEagerVertexAllocator.h"
#include <cstddef>
#include <queue>
#include <unordered_map>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes
struct	SSVertex
struct	GrAATriangulator::SSEdge
struct	GrAATriangulator::EventList

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

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	Comparator = GrTriangulator::Comparator
using	SSEdge = GrAATriangulator::SSEdge
using	EventList = GrAATriangulator::EventList
using	Event = GrAATriangulator::Event
using	EventComparator = GrAATriangulator::EventComparator
typedef std::unordered_map< Vertex *, SSVertex * >	SSVertexMap
typedef std::vector< SSEdge * >	SSEdgeList
typedef std::priority_queue< Event *, std::vector< Event * >, EventComparator >	EventPQ

Functions
static void	dump_skel (const SSEdgeList &ssEdges)
static void	get_edge_normal (const Edge *e, SkVector *normal)
static bool	is_overlap_edge (Edge *e)
static bool	inversion (Vertex *prev, Vertex *next, Edge *origEdge, const Comparator &c)

Variables
static constexpr float	kCosMiterAngle = 0.97f

Macro Definition Documentation

DUMP_MESH

#define DUMP_MESH

(

MESH

)

Definition at line 28 of file GrAATriangulator.cpp.

TESS_LOG

#define TESS_LOG

(

...

)

Definition at line 27 of file GrAATriangulator.cpp.

Typedef Documentation

Comparator

using Comparator = GrTriangulator::Comparator

Definition at line 40 of file GrAATriangulator.cpp.

Edge

using Edge = GrTriangulator::Edge

Definition at line 37 of file GrAATriangulator.cpp.

EdgeList

using EdgeList = GrTriangulator::EdgeList

Definition at line 38 of file GrAATriangulator.cpp.

EdgeType

using EdgeType = GrTriangulator::EdgeType

Definition at line 33 of file GrAATriangulator.cpp.

Event

using Event = GrAATriangulator::Event

Definition at line 43 of file GrAATriangulator.cpp.

EventComparator

using EventComparator = GrAATriangulator::EventComparator

Definition at line 44 of file GrAATriangulator.cpp.

EventList

using EventList = GrAATriangulator::EventList

Definition at line 42 of file GrAATriangulator.cpp.

EventPQ

typedef std::priority_queue<Event*, std::vector<Event*>, EventComparator> EventPQ

Definition at line 65 of file GrAATriangulator.cpp.

Line

using Line = GrTriangulator::Line

Definition at line 36 of file GrAATriangulator.cpp.

Poly

using Poly = GrTriangulator::Poly

Definition at line 39 of file GrAATriangulator.cpp.

SSEdge

using SSEdge = GrAATriangulator::SSEdge

Definition at line 41 of file GrAATriangulator.cpp.

SSEdgeList

typedef std::vector<SSEdge*> SSEdgeList

Definition at line 64 of file GrAATriangulator.cpp.

SSVertexMap

typedef std::unordered_map<Vertex*, SSVertex*> SSVertexMap

Definition at line 63 of file GrAATriangulator.cpp.

Vertex

using Vertex = GrTriangulator::Vertex

Definition at line 34 of file GrAATriangulator.cpp.

VertexList

using VertexList = GrTriangulator::VertexList

Definition at line 35 of file GrAATriangulator.cpp.

Function Documentation

dump_skel()

static void dump_skel ( const SSEdgeList &  ssEdges )

static

Definition at line 131 of file GrAATriangulator.cpp.

                                                 {
#if TRIANGULATOR_LOGGING
    for (SSEdge* edge : ssEdges) {
        if (edge->fEdge) {
            TESS_LOG("skel edge %g -> %g",
                edge->fPrev->fVertex->fID,
                edge->fNext->fVertex->fID);
            if (edge->fEdge->fTop && edge->fEdge->fBottom) {
                TESS_LOG(" (original %g -> %g)\n",
                         edge->fEdge->fTop->fID,
                         edge->fEdge->fBottom->fID);
            } else {
                TESS_LOG("\n");
            }
        }
    }
#endif
}

get_edge_normal()

static void get_edge_normal ( const Edge *  e, SkVector *  normal  )

static

Definition at line 183 of file GrAATriangulator.cpp.

                                                             {
    normal->set(SkDoubleToScalar(e->fLine.fA),
                SkDoubleToScalar(e->fLine.fB));
}

inversion()

static bool inversion ( Vertex *  prev, Vertex *  next, Edge *  origEdge, const Comparator &  c  )

static

Definition at line 406 of file GrAATriangulator.cpp.

                                                                                       {
    if (!prev || !next) {
        return true;
    }
    int winding = c.sweep_lt(prev->fPoint, next->fPoint) ? 1 : -1;
    return winding != origEdge->fWinding;
}

is_overlap_edge()

static bool is_overlap_edge ( Edge *  e )

static

Definition at line 304 of file GrAATriangulator.cpp.

                                     {
    if (e->fType == EdgeType::kOuter) {
        return e->fWinding != 0 && e->fWinding != 1;
    } else if (e->fType == EdgeType::kInner) {
        return e->fWinding != 0 && e->fWinding != -2;
    } else {
        return false;
    }
}

Variable Documentation

kCosMiterAngle

constexpr float kCosMiterAngle = 0.97f

staticconstexpr

Definition at line 31 of file GrAATriangulator.cpp.