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