1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Benchmark.h"
#include "SkPolyUtils.h"
class PolyUtilsBench : public Benchmark {
// Evaluate SkTriangulateSimplePolygon's performance (via derived classes) on:
// a non-self-intersecting star, a circle of tiny line segments and a self-intersecting star
SkString fName;
public:
PolyUtilsBench() {}
virtual void appendName(SkString*) = 0;
virtual void makePoly(SkTDArray<SkPoint>* poly) = 0;
virtual int complexity() { return 0; }
protected:
const char* onGetName() override {
fName = "poly_utils_";
this->appendName(&fName);
return fName.c_str();
}
void onDraw(int loops, SkCanvas* canvas) override {
SkTDArray<SkPoint> poly;
this->makePoly(&poly);
SkAutoSTMalloc<64, uint16_t> indexMap(poly.count());
for (int i = 0; i < poly.count(); ++i) {
indexMap[i] = i;
}
SkTDArray<uint16_t> triangleIndices;
for (int i = 0; i < loops; i++) {
if (SkIsSimplePolygon(poly.begin(), poly.count())) {
SkTriangulateSimplePolygon(poly.begin(), indexMap, poly.count(),
&triangleIndices);
}
}
}
private:
typedef Benchmark INHERITED;
};
class StarPolyUtilsBench : public PolyUtilsBench {
public:
StarPolyUtilsBench() {}
void appendName(SkString* name) override {
name->append("star");
}
void makePoly(SkTDArray<SkPoint>* poly) override {
// create non-intersecting star
const SkScalar c = SkIntToScalar(45);
const SkScalar r1 = SkIntToScalar(20);
const SkScalar r2 = SkIntToScalar(3);
const int n = 500;
SkScalar rad = 0;
const SkScalar drad = SK_ScalarPI / n;
for (int i = 0; i < n; i++) {
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
*poly->push() = SkPoint::Make(c + cosV * r1, c + sinV * r1);
rad += drad;
sinV = SkScalarSinCos(rad, &cosV);
*poly->push() = SkPoint::Make(c + cosV * r2, c + sinV * r2);
rad += drad;
}
}
private:
typedef PolyUtilsBench INHERITED;
};
class CirclePolyUtilsBench : public PolyUtilsBench {
public:
CirclePolyUtilsBench() {}
void appendName(SkString* name) override {
name->append("circle");
}
void makePoly(SkTDArray<SkPoint>* poly) override {
// create circle with many vertices
const SkScalar c = SkIntToScalar(45);
const SkScalar r = SkIntToScalar(20);
const int n = 1000;
SkScalar rad = 0;
const SkScalar drad = 2 * SK_ScalarPI / n;
for (int i = 0; i < n; i++) {
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
*poly->push() = SkPoint::Make(c + cosV * r, c + sinV * r);
rad += drad;
}
}
private:
typedef PolyUtilsBench INHERITED;
};
class IntersectingPolyUtilsBench : public PolyUtilsBench {
public:
IntersectingPolyUtilsBench() {}
void appendName(SkString* name) override {
name->append("intersecting");
}
void makePoly(SkTDArray<SkPoint>* poly) override {
// create self-intersecting star
const SkScalar c = SkIntToScalar(45);
const SkScalar r = SkIntToScalar(20);
const int n = 1000;
SkScalar rad = -SK_ScalarPI / 2;
const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
*poly->push() = SkPoint::Make(c, c - r);
for (int i = 1; i < n; i++) {
rad += drad;
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
*poly->push() = SkPoint::Make(c + cosV * r, c + sinV * r);
}
}
private:
typedef PolyUtilsBench INHERITED;
};
DEF_BENCH(return new StarPolyUtilsBench();)
DEF_BENCH(return new CirclePolyUtilsBench();)
DEF_BENCH(return new IntersectingPolyUtilsBench();)
|
