Inheritance diagram for PolyUtilsBench:

Public Types
enum class	Type { kConvexCheck , kSimpleCheck , kInsetConvex , kOffsetSimple , kTessellateSimple }

Public Types inherited from Benchmark
enum class	Backend { kNonRendering , kRaster , kGanesh , kGraphite , kPDF , kHWUI }

Public Member Functions
	PolyUtilsBench (Type type)

virtual void	appendName (SkString *)=0

virtual void	makePoly (SkTDArray< SkPoint > *poly)=0

virtual int	complexity ()

Public Member Functions inherited from Benchmark
	Benchmark ()

const char *	getName ()

const char *	getUniqueName ()

SkISize	getSize ()

virtual bool	isSuitableFor (Backend backend)

virtual void	modifyGrContextOptions (GrContextOptions *)

virtual bool	shouldLoop () const

void	delayedSetup ()

void	perCanvasPreDraw (SkCanvas *)

void	perCanvasPostDraw (SkCanvas *)

void	preDraw (SkCanvas *)

void	postDraw (SkCanvas *)

void	draw (int loops, SkCanvas *)

virtual void	getGpuStats (SkCanvas , skia_private::TArray< SkString > keys, skia_private::TArray< double > *values)

virtual bool	getDMSAAStats (GrRecordingContext *)

int	getUnits () const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Protected Member Functions
const char *	onGetName () override

void	onDraw (int loops, SkCanvas *canvas) override

Protected Member Functions inherited from Benchmark
void	setUnits (int units)

virtual void	setupPaint (SkPaint *paint)

virtual const char *	onGetName ()=0

virtual const char *	onGetUniqueName ()

virtual void	onDelayedSetup ()

virtual void	onPerCanvasPreDraw (SkCanvas *)

virtual void	onPerCanvasPostDraw (SkCanvas *)

virtual void	onPreDraw (SkCanvas *)

virtual void	onPostDraw (SkCanvas *)

virtual void	onDraw (int loops, SkCanvas *)=0

virtual SkISize	onGetSize ()

Detailed Description

Definition at line 19 of file PolyUtilsBench.cpp.

Member Enumeration Documentation

◆ Type

enum class PolyUtilsBench::Type

strong

Enumerator
kConvexCheck
kSimpleCheck
kInsetConvex
kOffsetSimple
kTessellateSimple

Definition at line 23 of file PolyUtilsBench.cpp.

23{ kConvexCheck, kSimpleCheck, kInsetConvex, kOffsetSimple, kTessellateSimple };

Constructor & Destructor Documentation

◆ PolyUtilsBench()

PolyUtilsBench::PolyUtilsBench ( Type type )

inline

Definition at line 25 of file PolyUtilsBench.cpp.

25: fType(type) {}

type

GLenum type

Definition: blit_command_gles.cc:126

Member Function Documentation

◆ appendName()

virtual void PolyUtilsBench::appendName ( SkString * )

pure virtual

Implemented in StarPolyUtilsBench, CirclePolyUtilsBench, IntersectingPolyUtilsBench, NotchPolyUtilsBench, and IceCreamPolyUtilsBench.

◆ complexity()

virtual int PolyUtilsBench::complexity ( )

inlinevirtual

Definition at line 29 of file PolyUtilsBench.cpp.

29{ return 0; }

◆ makePoly()

virtual void PolyUtilsBench::makePoly ( SkTDArray< SkPoint > * poly )

pure virtual

Implemented in StarPolyUtilsBench, CirclePolyUtilsBench, IntersectingPolyUtilsBench, NotchPolyUtilsBench, and IceCreamPolyUtilsBench.

◆ onDraw()

void PolyUtilsBench::onDraw	(	int	loops,
		SkCanvas *	canvas
	)

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 55 of file PolyUtilsBench.cpp.

                                                      {
        SkTDArray<SkPoint> poly;
        this->makePoly(&poly);
        switch (fType) {
            case Type::kConvexCheck:
                for (int i = 0; i < loops; i++) {
                    (void)SkIsConvexPolygon(poly.begin(), poly.size());
                }
                break;
            case Type::kSimpleCheck:
                for (int i = 0; i < loops; i++) {
                    (void)SkIsSimplePolygon(poly.begin(), poly.size());
                }
                break;
            case Type::kInsetConvex:
                if (SkIsConvexPolygon(poly.begin(), poly.size())) {
                    SkTDArray<SkPoint> result;
                    for (int i = 0; i < loops; i++) {
                        (void)SkInsetConvexPolygon(poly.begin(), poly.size(), 10, &result);
                        (void)SkInsetConvexPolygon(poly.begin(), poly.size(), 40, &result);
                    }
                }
                break;
            case Type::kOffsetSimple:
                if (SkIsSimplePolygon(poly.begin(), poly.size())) {
                    SkTDArray<SkPoint> result;
                    SkRect bounds;
                    bounds.setBounds(poly.begin(), poly.size());
                    for (int i = 0; i < loops; i++) {
                        (void)SkOffsetSimplePolygon(poly.begin(), poly.size(), bounds, 10,
                                                    &result);
                        (void)SkOffsetSimplePolygon(poly.begin(), poly.size(), bounds, -10,
                                                    &result);
                    }
                }
                break;
            case Type::kTessellateSimple:
                if (SkIsSimplePolygon(poly.begin(), poly.size())) {
                    AutoSTMalloc<64, uint16_t> indexMap(poly.size());
                    for (int i = 0; i < poly.size(); ++i) {
                        indexMap[i] = i;
                    }
                    SkTDArray<uint16_t> triangleIndices;
                    for (int i = 0; i < loops; i++) {
                        SkTriangulateSimplePolygon(poly.begin(), indexMap, poly.size(),
                                                   &triangleIndices);
                    }
                }
                break;
        }
    }

◆ onGetName()

const char * PolyUtilsBench::onGetName ( )