1/*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "Benchmark.h"
9#include "SkCanvas.h"
10#include "SkGradientShader.h"
11#include "SkPaint.h"
12#include "SkString.h"
13
14enum ColorPattern {
15    kWhite_ColorPattern,
16    kBlue_ColorPattern,
17    kOpaqueBitmap_ColorPattern,
18    kAlphaBitmap_ColorPattern,
19};
20
21static const struct ColorPatternData{
22    SkColor         fColor;
23    bool            fIsBitmap;
24    const char*     fName;
25} gColorPatterns[] = {
26    // Keep this in same order as ColorPattern enum
27    { SK_ColorWHITE, false,  "white"        }, // kWhite_ColorPattern
28    { SK_ColorBLUE,  false,  "blue"         }, // kBlue_ColorPattern
29    { SK_ColorWHITE, true,   "obaqueBitMap" }, // kOpaqueBitmap_ColorPattern
30    { 0x10000000,    true,   "alphaBitmap"  }, // kAlphaBitmap_ColorPattern
31};
32
33enum DrawType {
34    kRect_DrawType,
35    kPath_DrawType,
36};
37
38static void makebm(SkBitmap* bm, int w, int h) {
39    bm->allocN32Pixels(w, h);
40    bm->eraseColor(SK_ColorTRANSPARENT);
41
42    SkCanvas    canvas(*bm);
43    SkScalar    s = SkIntToScalar(SkMin32(w, h));
44    static const SkPoint     kPts0[] = { { 0, 0 }, { s, s } };
45    static const SkPoint     kPts1[] = { { s/2, 0 }, { s/2, s } };
46    static const SkScalar    kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
47    static const SkColor kColors0[] = {0x80F00080, 0xF0F08000, 0x800080F0 };
48    static const SkColor kColors1[] = {0xF08000F0, 0x8080F000, 0xF000F080 };
49
50
51    SkPaint     paint;
52
53    paint.setShader(SkGradientShader::CreateLinear(kPts0, kColors0, kPos,
54                    SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode))->unref();
55    canvas.drawPaint(paint);
56    paint.setShader(SkGradientShader::CreateLinear(kPts1, kColors1, kPos,
57                    SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode))->unref();
58    canvas.drawPaint(paint);
59}
60
61/**
62 * This bench draws a grid of either rects or filled paths, with two alternating color patterns.
63 * This color patterns are passed in as enums to the class. The options are:
64 *   1) solid white color
65 *   2) solid blue color
66 *   3) opaque bitmap
67 *   4) partial alpha bitmap
68 * The same color pattern can be set for both arguments to create a uniform pattern on all draws.
69 *
70 * The bench is used to test a few things. First it can test any optimizations made for a specific
71 * color pattern (for example drawing an opaque bitmap versus one with partial alpha). Also it can
72 * be used to test the cost of program switching and/or batching when alternating between different
73 * patterns when on the gpu.
74 */
75class AlternatingColorPatternBench : public Benchmark {
76public:
77    enum {
78        NX = 5,
79        NY = 5,
80        NUM_DRAWS = NX * NY,
81    };
82    SkShader* fBmShader;
83
84    SkPath  fPaths[NUM_DRAWS];
85    SkRect  fRects[NUM_DRAWS];
86    SkColor fColors[NUM_DRAWS];
87    SkShader* fShaders[NUM_DRAWS];
88
89    SkString        fName;
90    ColorPatternData    fPattern1;
91    ColorPatternData    fPattern2;
92    DrawType fDrawType;
93    SkBitmap fBmp;
94
95
96    AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType)
97        : fBmShader(NULL) {
98        fPattern1 = gColorPatterns[pattern1];
99        fPattern2 = gColorPatterns[pattern2];
100        fName.printf("colorPattern_%s_%s_%s",
101                     fPattern1.fName, fPattern2.fName,
102                     kRect_DrawType == drawType ? "rect" : "path");
103        fDrawType = drawType;
104    }
105
106    virtual ~AlternatingColorPatternBench() {
107        SkSafeUnref(fBmShader);
108    }
109
110protected:
111    virtual const char* onGetName() SK_OVERRIDE {
112        return fName.c_str();
113    }
114
115    virtual void onPreDraw() {
116        int w = 40;
117        int h = 40;
118        makebm(&fBmp, w, h);
119        fBmShader = SkShader::CreateBitmapShader(fBmp,
120                                                 SkShader::kRepeat_TileMode,
121                                                 SkShader::kRepeat_TileMode);
122        int offset = 2;
123        int count = 0;
124        for (int j = 0; j < NY; ++j) {
125            for (int i = 0; i < NX; ++i) {
126                int x = (w + offset) * i;
127                int y = (h * offset) * j;
128                if (kRect_DrawType == fDrawType) {
129                    fRects[count].set(SkIntToScalar(x), SkIntToScalar(y),
130                                      SkIntToScalar(x + w), SkIntToScalar(y + h));
131                } else {
132                    fPaths[count].moveTo(SkIntToScalar(x), SkIntToScalar(y));
133                    fPaths[count].rLineTo(SkIntToScalar(w), 0);
134                    fPaths[count].rLineTo(0, SkIntToScalar(h));
135                    fPaths[count].rLineTo(SkIntToScalar(-w + 1), 0);
136                }
137                if (0 == count % 2) {
138                    fColors[count]  = fPattern1.fColor;
139                    fShaders[count] = fPattern1.fIsBitmap ? fBmShader : NULL;
140                } else {
141                    fColors[count]  = fPattern2.fColor;
142                    fShaders[count] = fPattern2.fIsBitmap ? fBmShader : NULL;
143                }
144                ++count;
145            }
146        }
147    }
148
149    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
150        SkPaint paint;
151        paint.setAntiAlias(false);
152        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
153
154        for (int i = 0; i < loops; ++i) {
155            for (int j = 0; j < NUM_DRAWS; ++j) {
156                paint.setColor(fColors[j]);
157                paint.setShader(fShaders[j]);
158                if (kRect_DrawType == fDrawType) {
159                    canvas->drawRect(fRects[j], paint);
160                } else {
161                    canvas->drawPath(fPaths[j], paint);
162                }
163            }
164        }
165    }
166
167private:
168    typedef Benchmark INHERITED;
169};
170
171DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
172                             (kWhite_ColorPattern, kWhite_ColorPattern,
173                              kPath_DrawType)); )
174DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
175                             (kBlue_ColorPattern, kBlue_ColorPattern,
176                              kPath_DrawType)); )
177DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
178                             (kWhite_ColorPattern, kBlue_ColorPattern,
179                              kPath_DrawType)); )
180
181DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
182                             (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
183                              kPath_DrawType)); )
184DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
185                             (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
186                              kPath_DrawType)); )
187DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
188                             (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
189                              kPath_DrawType)); )
190
191DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
192                             (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
193                              kRect_DrawType)); )
194DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
195                             (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
196                              kRect_DrawType)); )
197DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
198                             (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
199                              kRect_DrawType)); )
200
201