blob: e62fb532536308213c285109ffb846bb005e1923 [file] [log] [blame]
reed@google.com4aa1a702012-05-04 16:37:45 +00001
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8#include "SkBenchmark.h"
9#include "SkBitmap.h"
10#include "SkCanvas.h"
11#include "SkDashPathEffect.h"
12#include "SkPaint.h"
13#include "SkPath.h"
14#include "SkRandom.h"
15#include "SkString.h"
16#include "SkTDArray.h"
17
reed@google.comef85e3c2012-05-10 15:40:57 +000018
reed@google.com4aa1a702012-05-04 16:37:45 +000019/*
20 * Cases to consider:
21 *
22 * 1. antialiasing on/off (esp. width <= 1)
23 * 2. strokewidth == 0, 1, 2
24 * 3. hline, vline, diagonal, rect, oval
25 * 4. dots [1,1] ([N,N] where N=strokeWidth?) or arbitrary (e.g. [2,1] or [1,2,3,2])
26 */
27static void path_hline(SkPath* path) {
28 path->moveTo(SkIntToScalar(10), SkIntToScalar(10));
29 path->lineTo(SkIntToScalar(600), SkIntToScalar(10));
30}
31
32class DashBench : public SkBenchmark {
reed@google.comef85e3c2012-05-10 15:40:57 +000033protected:
mike@reedtribe.org99a6ef42012-05-05 13:46:10 +000034 SkString fName;
reed@google.com4aa1a702012-05-04 16:37:45 +000035 SkTDArray<SkScalar> fIntervals;
mike@reedtribe.org99a6ef42012-05-05 13:46:10 +000036 int fWidth;
reed@google.coma584aed2012-05-16 14:06:02 +000037 SkPoint fPts[2];
38 bool fDoClip;
reed@google.com4aa1a702012-05-04 16:37:45 +000039
40 enum {
41 N = SkBENCHLOOP(100)
42 };
43public:
reed@google.com4ad22752012-05-15 19:50:58 +000044 DashBench(void* param, const SkScalar intervals[], int count, int width,
45 bool doClip = false) : INHERITED(param) {
reed@google.com4aa1a702012-05-04 16:37:45 +000046 fIntervals.append(count, intervals);
mike@reedtribe.org99a6ef42012-05-05 13:46:10 +000047 for (int i = 0; i < count; ++i) {
48 fIntervals[i] *= width;
49 }
50 fWidth = width;
reed@google.com4ad22752012-05-15 19:50:58 +000051 fName.printf("dash_%d_%s", width, doClip ? "clipped" : "noclip");
52 fDoClip = doClip;
rmistry@google.comfbfcd562012-08-23 18:09:54 +000053
reed@google.coma584aed2012-05-16 14:06:02 +000054 fPts[0].set(SkIntToScalar(10), SkIntToScalar(10));
55 fPts[1].set(SkIntToScalar(600), SkIntToScalar(10));
reed@google.com4aa1a702012-05-04 16:37:45 +000056 }
57
58 virtual void makePath(SkPath* path) {
59 path_hline(path);
60 }
61
62protected:
63 virtual const char* onGetName() SK_OVERRIDE {
mike@reedtribe.org99a6ef42012-05-05 13:46:10 +000064 return fName.c_str();
reed@google.com4aa1a702012-05-04 16:37:45 +000065 }
66
67 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
68 SkPaint paint;
69 this->setupPaint(&paint);
70 paint.setStyle(SkPaint::kStroke_Style);
mike@reedtribe.org99a6ef42012-05-05 13:46:10 +000071 paint.setStrokeWidth(SkIntToScalar(fWidth));
reed@google.com4aa1a702012-05-04 16:37:45 +000072 paint.setAntiAlias(false);
73
74 SkPath path;
75 this->makePath(&path);
76
77 paint.setPathEffect(new SkDashPathEffect(fIntervals.begin(),
78 fIntervals.count(), 0))->unref();
reed@google.com4ad22752012-05-15 19:50:58 +000079
80 if (fDoClip) {
81 SkRect r = path.getBounds();
82 r.inset(-SkIntToScalar(20), -SkIntToScalar(20));
83 // now move it so we don't intersect
84 r.offset(0, r.height() * 3 / 2);
85 canvas->clipRect(r);
86 }
87
reed@google.comef85e3c2012-05-10 15:40:57 +000088 this->handlePath(canvas, path, paint, N);
89 }
90
91 virtual void handlePath(SkCanvas* canvas, const SkPath& path,
92 const SkPaint& paint, int N) {
reed@google.com4aa1a702012-05-04 16:37:45 +000093 for (int i = 0; i < N; ++i) {
reed@google.coma584aed2012-05-16 14:06:02 +000094// canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, paint);
reed@google.com4aa1a702012-05-04 16:37:45 +000095 canvas->drawPath(path, paint);
96 }
97 }
98
99private:
100 typedef SkBenchmark INHERITED;
101};
102
reed@google.comef85e3c2012-05-10 15:40:57 +0000103class RectDashBench : public DashBench {
104public:
reed@google.com4ad22752012-05-15 19:50:58 +0000105 RectDashBench(void* param, const SkScalar intervals[], int count, int width, bool doClip = false)
reed@google.comef85e3c2012-05-10 15:40:57 +0000106 : INHERITED(param, intervals, count, width) {
107 fName.append("_rect");
108 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000109
reed@google.comef85e3c2012-05-10 15:40:57 +0000110protected:
111 virtual void handlePath(SkCanvas* canvas, const SkPath& path,
112 const SkPaint& paint, int N) SK_OVERRIDE {
113 SkPoint pts[2];
114 if (!path.isLine(pts) || pts[0].fY != pts[1].fY) {
115 this->INHERITED::handlePath(canvas, path, paint, N);
116 } else {
117 SkRect rect;
118 rect.fLeft = pts[0].fX;
119 rect.fTop = pts[0].fY - paint.getStrokeWidth() / 2;
120 rect.fRight = rect.fLeft + SkIntToScalar(fWidth);
121 rect.fBottom = rect.fTop + paint.getStrokeWidth();
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000122
reed@google.comef85e3c2012-05-10 15:40:57 +0000123 SkPaint p(paint);
124 p.setStyle(SkPaint::kFill_Style);
125 p.setPathEffect(NULL);
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000126
reed@google.comef85e3c2012-05-10 15:40:57 +0000127 int count = SkScalarRoundToInt((pts[1].fX - pts[0].fX) / (2*fWidth));
128 SkScalar dx = SkIntToScalar(2 * fWidth);
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000129
reed@google.comef85e3c2012-05-10 15:40:57 +0000130 for (int i = 0; i < N*10; ++i) {
131 SkRect r = rect;
132 for (int j = 0; j < count; ++j) {
133 canvas->drawRect(r, p);
134 r.offset(dx, 0);
135 }
136 }
137 }
138 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000139
reed@google.comef85e3c2012-05-10 15:40:57 +0000140private:
141 typedef DashBench INHERITED;
142};
143
reed@google.comea6f6832012-05-18 18:32:54 +0000144static void make_unit_star(SkPath* path, int n) {
145 SkScalar rad = -SK_ScalarPI / 2;
146 const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000147
reed@google.comea6f6832012-05-18 18:32:54 +0000148 path->moveTo(0, -SK_Scalar1);
149 for (int i = 1; i < n; i++) {
150 rad += drad;
151 SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
152 path->lineTo(cosV, sinV);
153 }
154 path->close();
155}
156
157static void make_poly(SkPath* path) {
158 make_unit_star(path, 9);
159 SkMatrix matrix;
160 matrix.setScale(SkIntToScalar(100), SkIntToScalar(100));
161 path->transform(matrix);
162}
163
164static void make_quad(SkPath* path) {
165 SkScalar x0 = SkIntToScalar(10);
166 SkScalar y0 = SkIntToScalar(10);
167 path->moveTo(x0, y0);
168 path->quadTo(x0, y0 + 400 * SK_Scalar1,
169 x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1);
170}
171
172static void make_cubic(SkPath* path) {
173 SkScalar x0 = SkIntToScalar(10);
174 SkScalar y0 = SkIntToScalar(10);
175 path->moveTo(x0, y0);
176 path->cubicTo(x0, y0 + 400 * SK_Scalar1,
177 x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1,
178 x0 + 600 * SK_Scalar1, y0);
179}
180
181class MakeDashBench : public SkBenchmark {
182 SkString fName;
183 SkPath fPath;
184 SkAutoTUnref<SkPathEffect> fPE;
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000185
reed@google.comea6f6832012-05-18 18:32:54 +0000186 enum {
187 N = SkBENCHLOOP(400)
188 };
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000189
reed@google.comea6f6832012-05-18 18:32:54 +0000190public:
191 MakeDashBench(void* param, void (*proc)(SkPath*), const char name[]) : INHERITED(param) {
192 fName.printf("makedash_%s", name);
193 proc(&fPath);
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000194
reed@google.comea6f6832012-05-18 18:32:54 +0000195 SkScalar vals[] = { SkIntToScalar(4), SkIntToScalar(4) };
196 fPE.reset(new SkDashPathEffect(vals, 2, 0));
197 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000198
reed@google.comea6f6832012-05-18 18:32:54 +0000199protected:
200 virtual const char* onGetName() SK_OVERRIDE {
201 return fName.c_str();
202 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000203
reed@google.comea6f6832012-05-18 18:32:54 +0000204 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
205 SkPath dst;
206 for (int i = 0; i < N; ++i) {
reed@google.comfd4be262012-05-25 01:04:12 +0000207 SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000208
reed@google.com4bbdeac2013-01-24 21:03:11 +0000209 fPE->filterPath(&dst, fPath, &rec, NULL);
reed@google.comea6f6832012-05-18 18:32:54 +0000210 dst.rewind();
211 }
212 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000213
reed@google.com31e9d642012-09-04 20:07:23 +0000214private:
215 typedef SkBenchmark INHERITED;
216};
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000217
reed@google.com5125d842012-09-04 20:19:35 +0000218/*
219 * We try to special case square dashes (intervals are equal to strokewidth).
220 */
reed@google.com31e9d642012-09-04 20:07:23 +0000221class DashLineBench : public SkBenchmark {
222 SkString fName;
reed@google.com5125d842012-09-04 20:19:35 +0000223 SkScalar fStrokeWidth;
224 bool fIsRound;
reed@google.com31e9d642012-09-04 20:07:23 +0000225 SkAutoTUnref<SkPathEffect> fPE;
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000226
reed@google.com31e9d642012-09-04 20:07:23 +0000227 enum {
228 N = SkBENCHLOOP(200)
229 };
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000230
reed@google.com31e9d642012-09-04 20:07:23 +0000231public:
reed@google.com5125d842012-09-04 20:19:35 +0000232 DashLineBench(void* param, SkScalar width, bool isRound) : INHERITED(param) {
233 fName.printf("dashline_%g_%s", SkScalarToFloat(width), isRound ? "circle" : "square");
234 fStrokeWidth = width;
235 fIsRound = isRound;
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000236
reed@google.com5125d842012-09-04 20:19:35 +0000237 SkScalar vals[] = { SK_Scalar1, SK_Scalar1 };
reed@google.com31e9d642012-09-04 20:07:23 +0000238 fPE.reset(new SkDashPathEffect(vals, 2, 0));
239 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000240
reed@google.com31e9d642012-09-04 20:07:23 +0000241protected:
242 virtual const char* onGetName() SK_OVERRIDE {
243 return fName.c_str();
244 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000245
reed@google.com31e9d642012-09-04 20:07:23 +0000246 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
247 SkPaint paint;
248 this->setupPaint(&paint);
reed@google.com5125d842012-09-04 20:19:35 +0000249 paint.setStrokeWidth(fStrokeWidth);
250 paint.setStrokeCap(fIsRound ? SkPaint::kRound_Cap : SkPaint::kSquare_Cap);
reed@google.com31e9d642012-09-04 20:07:23 +0000251 paint.setPathEffect(fPE);
252 for (int i = 0; i < N; ++i) {
reed@google.com5125d842012-09-04 20:19:35 +0000253 canvas->drawLine(10 * SK_Scalar1, 10 * SK_Scalar1,
254 640 * SK_Scalar1, 10 * SK_Scalar1, paint);
reed@google.com31e9d642012-09-04 20:07:23 +0000255 }
256 }
skia.committer@gmail.com73bb3be2012-09-05 02:01:29 +0000257
reed@google.comea6f6832012-05-18 18:32:54 +0000258private:
259 typedef SkBenchmark INHERITED;
260};
261
robertphillips@google.com935ad022012-12-05 19:07:21 +0000262class DrawPointsDashingBench : public SkBenchmark {
263 SkString fName;
264 int fStrokeWidth;
robertphillips@google.comca47aae2012-12-12 15:58:25 +0000265 bool fDoAA;
robertphillips@google.com935ad022012-12-05 19:07:21 +0000266
267 SkAutoTUnref<SkPathEffect> fPathEffect;
268
269 enum {
270 N = SkBENCHLOOP(480)
271 };
272
273public:
skia.committer@gmail.com0264fb42012-12-06 02:01:25 +0000274 DrawPointsDashingBench(void* param, int dashLength, int strokeWidth, bool doAA)
robertphillips@google.com935ad022012-12-05 19:07:21 +0000275 : INHERITED(param) {
276 fName.printf("drawpointsdash_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
277 fStrokeWidth = strokeWidth;
robertphillips@google.comca47aae2012-12-12 15:58:25 +0000278 fDoAA = doAA;
robertphillips@google.com935ad022012-12-05 19:07:21 +0000279
280 SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) };
281 fPathEffect.reset(new SkDashPathEffect(vals, 2, SK_Scalar1, false));
282 }
283
284protected:
285 virtual const char* onGetName() SK_OVERRIDE {
286 return fName.c_str();
287 }
288
289 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
290
291 SkPaint p;
292 this->setupPaint(&p);
293 p.setColor(SK_ColorBLACK);
294 p.setStyle(SkPaint::kStroke_Style);
295 p.setStrokeWidth(SkIntToScalar(fStrokeWidth));
296 p.setPathEffect(fPathEffect);
robertphillips@google.comca47aae2012-12-12 15:58:25 +0000297 p.setAntiAlias(fDoAA);
robertphillips@google.com935ad022012-12-05 19:07:21 +0000298
299 SkPoint pts[2] = {
300 { SkIntToScalar(10), 0 },
301 { SkIntToScalar(640), 0 }
302 };
303
304 for (int i = 0; i < N; ++i) {
305
306 pts[0].fY = pts[1].fY = SkIntToScalar(i % 480);
307 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
308 }
309 }
310
311private:
312 typedef SkBenchmark INHERITED;
313};
reed@google.com996f64f2013-01-24 17:17:28 +0000314
reed@google.come5ceea92013-01-24 17:33:21 +0000315// Want to test how we handle dashing when 99% of the dash is clipped out
reed@google.com996f64f2013-01-24 17:17:28 +0000316class GiantDashBench : public SkBenchmark {
317 SkString fName;
reed@google.come5ceea92013-01-24 17:33:21 +0000318 SkScalar fStrokeWidth;
reed@google.com996f64f2013-01-24 17:17:28 +0000319 SkPoint fPts[2];
320 SkAutoTUnref<SkPathEffect> fPathEffect;
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000321
reed@google.com996f64f2013-01-24 17:17:28 +0000322public:
323 enum LineType {
324 kHori_LineType,
325 kVert_LineType,
326 kDiag_LineType
327 };
328
329 static const char* LineTypeName(LineType lt) {
330 static const char* gNames[] = { "hori", "vert", "diag" };
331 SkASSERT((size_t)lt <= SK_ARRAY_COUNT(gNames));
332 return gNames[lt];
333 }
334
reed@google.come5ceea92013-01-24 17:33:21 +0000335 GiantDashBench(void* param, LineType lt, SkScalar width) : INHERITED(param) {
336 fName.printf("giantdashline_%s_%g", LineTypeName(lt), width);
337 fStrokeWidth = width;
338
reed@google.com996f64f2013-01-24 17:17:28 +0000339 // deliberately pick intervals that won't be caught by asPoints(), so
340 // we can test the filterPath code-path.
reed@google.comc270baf2013-01-24 18:43:32 +0000341 const SkScalar intervals[] = { 2, 1, 1, 1 };
reed@google.com996f64f2013-01-24 17:17:28 +0000342 fPathEffect.reset(new SkDashPathEffect(intervals,
343 SK_ARRAY_COUNT(intervals), 0));
344
345 SkScalar cx = 640 / 2; // center X
346 SkScalar cy = 480 / 2; // center Y
347 SkMatrix matrix;
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000348
reed@google.com996f64f2013-01-24 17:17:28 +0000349 switch (lt) {
350 case kHori_LineType:
351 matrix.setIdentity();
352 break;
353 case kVert_LineType:
354 matrix.setRotate(90, cx, cy);
355 break;
356 case kDiag_LineType:
357 matrix.setRotate(45, cx, cy);
358 break;
359 }
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000360
reed@google.come5ceea92013-01-24 17:33:21 +0000361 const SkScalar overshoot = 100*1000;
reed@google.com996f64f2013-01-24 17:17:28 +0000362 const SkPoint pts[2] = {
363 { -overshoot, cy }, { 640 + overshoot, cy }
364 };
365 matrix.mapPoints(fPts, pts, 2);
366 }
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000367
reed@google.com996f64f2013-01-24 17:17:28 +0000368protected:
369 virtual const char* onGetName() SK_OVERRIDE {
370 return fName.c_str();
371 }
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000372
reed@google.com996f64f2013-01-24 17:17:28 +0000373 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
374 SkPaint p;
375 this->setupPaint(&p);
376 p.setStyle(SkPaint::kStroke_Style);
reed@google.come5ceea92013-01-24 17:33:21 +0000377 p.setStrokeWidth(fStrokeWidth);
reed@google.com996f64f2013-01-24 17:17:28 +0000378 p.setPathEffect(fPathEffect);
379
reed@google.come5ceea92013-01-24 17:33:21 +0000380 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, p);
reed@google.com996f64f2013-01-24 17:17:28 +0000381 }
skia.committer@gmail.com4024f322013-01-25 07:06:46 +0000382
reed@google.com996f64f2013-01-24 17:17:28 +0000383private:
384 typedef SkBenchmark INHERITED;
385};
386
387
reed@google.com4aa1a702012-05-04 16:37:45 +0000388///////////////////////////////////////////////////////////////////////////////
389
390static const SkScalar gDots[] = { SK_Scalar1, SK_Scalar1 };
391
392#define PARAM(array) array, SK_ARRAY_COUNT(array)
393
reed@google.coma8f23c72013-01-24 16:56:36 +0000394DEF_BENCH( return new DashBench(p, PARAM(gDots), 0); )
395DEF_BENCH( return new DashBench(p, PARAM(gDots), 1); )
396DEF_BENCH( return new DashBench(p, PARAM(gDots), 1, true); )
397DEF_BENCH( return new DashBench(p, PARAM(gDots), 4); )
398DEF_BENCH( return new MakeDashBench(p, make_poly, "poly"); )
399DEF_BENCH( return new MakeDashBench(p, make_quad, "quad"); )
400DEF_BENCH( return new MakeDashBench(p, make_cubic, "cubic"); )
401DEF_BENCH( return new DashLineBench(p, 0, false); )
402DEF_BENCH( return new DashLineBench(p, SK_Scalar1, false); )
403DEF_BENCH( return new DashLineBench(p, 2 * SK_Scalar1, false); )
404DEF_BENCH( return new DashLineBench(p, 0, true); )
405DEF_BENCH( return new DashLineBench(p, SK_Scalar1, true); )
406DEF_BENCH( return new DashLineBench(p, 2 * SK_Scalar1, true); )
reed@google.com4aa1a702012-05-04 16:37:45 +0000407
reed@google.coma8f23c72013-01-24 16:56:36 +0000408DEF_BENCH( return new DrawPointsDashingBench(p, 1, 1, false); )
409DEF_BENCH( return new DrawPointsDashingBench(p, 1, 1, true); )
410DEF_BENCH( return new DrawPointsDashingBench(p, 3, 1, false); )
411DEF_BENCH( return new DrawPointsDashingBench(p, 3, 1, true); )
412DEF_BENCH( return new DrawPointsDashingBench(p, 5, 5, false); )
413DEF_BENCH( return new DrawPointsDashingBench(p, 5, 5, true); )
reed@google.com996f64f2013-01-24 17:17:28 +0000414
reed@google.come5ceea92013-01-24 17:33:21 +0000415DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kHori_LineType, 0); )
416DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kVert_LineType, 0); )
417DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kDiag_LineType, 0); )
418
419// pass 2 to explicitly avoid any 1-is-the-same-as-hairline special casing
420
421// hori_2 is just too slow to enable at the moment
reed@google.com4bbdeac2013-01-24 21:03:11 +0000422DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kHori_LineType, 2); )
reed@google.come5ceea92013-01-24 17:33:21 +0000423DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kVert_LineType, 2); )
424DEF_BENCH( return new GiantDashBench(p, GiantDashBench::kDiag_LineType, 2); )