1/*
2 * Copyright 2013 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#include "Benchmark.h"
8#include "SkCanvas.h"
9#include "SkLightingImageFilter.h"
10#include "SkPoint3.h"
11
12#define FILTER_WIDTH_SMALL  SkIntToScalar(32)
13#define FILTER_HEIGHT_SMALL SkIntToScalar(32)
14#define FILTER_WIDTH_LARGE  SkIntToScalar(256)
15#define FILTER_HEIGHT_LARGE SkIntToScalar(256)
16
17class LightingBaseBench : public Benchmark {
18public:
19    LightingBaseBench(bool small) : fIsSmall(small) { }
20
21protected:
22    void draw(int loops, SkCanvas* canvas, sk_sp<SkImageFilter> imageFilter) const {
23        SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
24                              SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
25        SkPaint paint;
26        paint.setImageFilter(std::move(imageFilter));
27        for (int i = 0; i < loops; i++) {
28            canvas->drawRect(r, paint);
29        }
30    }
31
32    static SkPoint3 GetPointLocation() {
33        static SkPoint3 pointLocation = SkPoint3::Make(0, 0, SkIntToScalar(10));
34        return pointLocation;
35    }
36
37    static SkPoint3 GetDistantDirection() {
38        static SkScalar azimuthRad = SkDegreesToRadians(SkIntToScalar(225));
39        static SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5));
40        static SkPoint3 distantDirection = SkPoint3::Make(
41                                              SkScalarCos(azimuthRad) * SkScalarCos(elevationRad),
42                                              SkScalarSin(azimuthRad) * SkScalarCos(elevationRad),
43                                              SkScalarSin(elevationRad));
44        return distantDirection;
45    }
46
47    static SkPoint3 GetSpotLocation() {
48        static SkPoint3 spotLocation = SkPoint3::Make(SkIntToScalar(-10),
49                                                      SkIntToScalar(-10),
50                                                      SkIntToScalar(20));
51        return spotLocation;
52    }
53
54    static SkPoint3 GetSpotTarget() {
55        static SkPoint3 spotTarget = SkPoint3::Make(SkIntToScalar(40), SkIntToScalar(40), 0);
56        return spotTarget;
57    }
58
59    static SkScalar GetSpotExponent() {
60        static SkScalar spotExponent = SK_Scalar1;
61        return spotExponent;
62    }
63
64    static SkScalar GetCutoffAngle() {
65        static SkScalar cutoffAngle = SkIntToScalar(15);
66        return cutoffAngle;
67    }
68
69    static SkScalar GetKd() {
70        static SkScalar kd = SkIntToScalar(2);
71        return kd;
72    }
73
74    static SkScalar GetKs() {
75        static SkScalar ks = SkIntToScalar(1);
76        return ks;
77    }
78
79    static SkScalar GetShininess() {
80        static SkScalar shininess = SkIntToScalar(8);
81        return shininess;
82    }
83
84    static SkScalar GetSurfaceScale() {
85        static SkScalar surfaceScale = SkIntToScalar(1);
86        return surfaceScale;
87    }
88
89    static SkColor GetWhite() {
90        static SkColor white(0xFFFFFFFF);
91        return white;
92    }
93
94    bool fIsSmall;
95    typedef Benchmark INHERITED;
96};
97
98class LightingPointLitDiffuseBench : public LightingBaseBench {
99public:
100    LightingPointLitDiffuseBench(bool small) : INHERITED(small) { }
101
102protected:
103    const char* onGetName() override {
104        return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdiffuse_large";
105    }
106
107    void onDraw(int loops, SkCanvas* canvas) override {
108        draw(loops, canvas, SkLightingImageFilter::MakePointLitDiffuse(GetPointLocation(),
109                                                                       GetWhite(),
110                                                                       GetSurfaceScale(),
111                                                                       GetKd(),
112                                                                       nullptr));
113    }
114
115private:
116    typedef LightingBaseBench INHERITED;
117};
118
119class LightingDistantLitDiffuseBench : public LightingBaseBench {
120public:
121    LightingDistantLitDiffuseBench(bool small) : INHERITED(small) { }
122
123protected:
124    const char* onGetName() override {
125        return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantlitdiffuse_large";
126    }
127
128    void onDraw(int loops, SkCanvas* canvas) override {
129        draw(loops, canvas, SkLightingImageFilter::MakeDistantLitDiffuse(GetDistantDirection(),
130                                                                         GetWhite(),
131                                                                         GetSurfaceScale(),
132                                                                         GetKd(),
133                                                                         nullptr));
134    }
135
136private:
137    typedef LightingBaseBench INHERITED;
138};
139
140class LightingSpotLitDiffuseBench : public LightingBaseBench {
141public:
142    LightingSpotLitDiffuseBench(bool small) : INHERITED(small) { }
143
144protected:
145    const char* onGetName() override {
146        return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffuse_large";
147    }
148
149    void onDraw(int loops, SkCanvas* canvas) override {
150        draw(loops, canvas, SkLightingImageFilter::MakeSpotLitDiffuse(GetSpotLocation(),
151                                                                       GetSpotTarget(),
152                                                                       GetSpotExponent(),
153                                                                       GetCutoffAngle(),
154                                                                       GetWhite(),
155                                                                       GetSurfaceScale(),
156                                                                       GetKd(),
157                                                                       nullptr));
158    }
159
160private:
161    typedef LightingBaseBench INHERITED;
162};
163
164class LightingPointLitSpecularBench : public LightingBaseBench {
165public:
166    LightingPointLitSpecularBench(bool small) : INHERITED(small) { }
167
168protected:
169    const char* onGetName() override {
170        return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitspecular_large";
171    }
172
173    void onDraw(int loops, SkCanvas* canvas) override {
174        draw(loops, canvas, SkLightingImageFilter::MakePointLitSpecular(GetPointLocation(),
175                                                                        GetWhite(),
176                                                                        GetSurfaceScale(),
177                                                                        GetKs(),
178                                                                        GetShininess(),
179                                                                        nullptr));
180    }
181
182private:
183    typedef LightingBaseBench INHERITED;
184};
185
186class LightingDistantLitSpecularBench : public LightingBaseBench {
187public:
188    LightingDistantLitSpecularBench(bool small) : INHERITED(small) { }
189
190protected:
191    const char* onGetName() override {
192        return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantlitspecular_large";
193    }
194
195    void onDraw(int loops, SkCanvas* canvas) override {
196        draw(loops, canvas, SkLightingImageFilter::MakeDistantLitSpecular(GetDistantDirection(),
197                                                                          GetWhite(),
198                                                                          GetSurfaceScale(),
199                                                                          GetKs(),
200                                                                          GetShininess(),
201                                                                          nullptr));
202    }
203
204private:
205    typedef LightingBaseBench INHERITED;
206};
207
208class LightingSpotLitSpecularBench : public LightingBaseBench {
209public:
210    LightingSpotLitSpecularBench(bool small) : INHERITED(small) { }
211
212protected:
213    const char* onGetName() override {
214        return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspecular_large";
215    }
216
217    void onDraw(int loops, SkCanvas* canvas) override {
218        draw(loops, canvas, SkLightingImageFilter::MakeSpotLitSpecular(GetSpotLocation(),
219                                                                       GetSpotTarget(),
220                                                                       GetSpotExponent(),
221                                                                       GetCutoffAngle(),
222                                                                       GetWhite(),
223                                                                       GetSurfaceScale(),
224                                                                       GetKs(),
225                                                                       GetShininess(),
226                                                                       nullptr));
227    }
228
229private:
230    typedef LightingBaseBench INHERITED;
231};
232
233///////////////////////////////////////////////////////////////////////////////
234
235DEF_BENCH( return new LightingPointLitDiffuseBench(true); )
236DEF_BENCH( return new LightingPointLitDiffuseBench(false); )
237DEF_BENCH( return new LightingDistantLitDiffuseBench(true); )
238DEF_BENCH( return new LightingDistantLitDiffuseBench(false); )
239DEF_BENCH( return new LightingSpotLitDiffuseBench(true); )
240DEF_BENCH( return new LightingSpotLitDiffuseBench(false); )
241DEF_BENCH( return new LightingPointLitSpecularBench(true); )
242DEF_BENCH( return new LightingPointLitSpecularBench(false); )
243DEF_BENCH( return new LightingDistantLitSpecularBench(true); )
244DEF_BENCH( return new LightingDistantLitSpecularBench(false); )
245DEF_BENCH( return new LightingSpotLitSpecularBench(true); )
246DEF_BENCH( return new LightingSpotLitSpecularBench(false); )
247