PathOpsBench.cpp File Reference

#include "bench/Benchmark.h"
#include "include/core/SkPath.h"
#include "include/core/SkShader.h"
#include "include/core/SkString.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkTArray.h"
#include "src/base/SkRandom.h"
#include "include/core/SkPathBuilder.h"

Go to the source code of this file.

Classes
class	PathOpsBench
class	PathOpsSimplifyBench
class	PathBuilderBench

Enumerations
enum class	MakeType { kPath , kSnapshot , kDetach , kArray }

Functions
static SkPath	makerects ()
	DEF_BENCH (return new PathOpsSimplifyBench("rects", makerects());) template< size_t N > struct ArrayPath
template<typename T >
void	run_builder (T &b, bool useReserve, int N)

Enumeration Type Documentation

MakeType

enum class MakeType

strong

Enumerator
kPath
kSnapshot
kDetach
kArray

Definition at line 140 of file PathOpsBench.cpp.

                    {
    kPath,
    kSnapshot,
    kDetach,
    kArray,
};

Function Documentation

DEF_BENCH()

DEF_BENCH

(

return new PathOpsSimplifyBench("rects", makerects());

)

Definition at line 95 of file PathOpsBench.cpp.

                                     {
    SkPoint fPts[N];
    uint8_t fVbs[N];
    int fPIndex = 0, fVIndex = 0;
 
    void moveTo(float x, float y) {
        fVbs[fVIndex++] = (uint8_t)SkPathVerb::kMove;
        fPts[fPIndex++] = {x, y};
    }
    void lineTo(float x, float y) {
        fVbs[fVIndex++] = (uint8_t)SkPathVerb::kLine;
        fPts[fPIndex++] = {x, y};
    }
    void quadTo(float x, float y, float x1, float y1) {
        fVbs[fVIndex++] = (uint8_t)SkPathVerb::kQuad;
        fPts[fPIndex++] = {x, y};
        fPts[fPIndex++] = {x1, y1};
    }
    void cubicTo(float x, float y, float x1, float y1, float x2, float y2) {
        fVbs[fVIndex++] = (uint8_t)SkPathVerb::kCubic;
        fPts[fPIndex++] = {x, y};
        fPts[fPIndex++] = {x1, y1};
        fPts[fPIndex++] = {x2, y2};
    }
    void incReserve(int) {}
};

makerects()

static SkPath makerects ( )

static

Definition at line 84 of file PathOpsBench.cpp.

                          {
    SkRandom rand;
    SkPath path;
    SkScalar scale = 100;
    for (int i = 0; i < 20; ++i) {
        SkScalar x = rand.nextUScalar1() * scale;
        SkScalar y = rand.nextUScalar1() * scale;
        path.addRect({x, y, x + scale, y + scale});
    }
    return path;
}

run_builder()

template<typename T >

void run_builder	(	T &	b,
		bool	useReserve,
		int	N
	)

Definition at line 126 of file PathOpsBench.cpp.

                                                                     {
    if (useReserve) {
        b.incReserve(N * 12);
    }
 
    float x = 0, y = 0;
    b.moveTo(x, y);
    for (int i = 1; i < N; ++i) {
        b.lineTo(x, y);
        b.quadTo(x, y, x, y);
        b.cubicTo(x, y, x, y, x, y);
    }
}