OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 #include "Benchmark.h" | 7 #include "Benchmark.h" |
8 #include "SkBitmapSource.h" | 8 #include "SkBitmapSource.h" |
9 #include "SkCanvas.h" | 9 #include "SkCanvas.h" |
10 #include "SkDevice.h" | 10 #include "SkDevice.h" |
11 #include "SkLightingImageFilter.h" | 11 #include "SkLightingImageFilter.h" |
| 12 #include "SkPoint3.h" |
12 | 13 |
13 #define FILTER_WIDTH_SMALL SkIntToScalar(32) | 14 #define FILTER_WIDTH_SMALL SkIntToScalar(32) |
14 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) | 15 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) |
15 #define FILTER_WIDTH_LARGE SkIntToScalar(256) | 16 #define FILTER_WIDTH_LARGE SkIntToScalar(256) |
16 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) | 17 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) |
17 | 18 |
18 class LightingBaseBench : public Benchmark { | 19 class LightingBaseBench : public Benchmark { |
19 public: | 20 public: |
20 LightingBaseBench(bool small) : fIsSmall(small) { } | 21 LightingBaseBench(bool small) : fIsSmall(small) { } |
21 | 22 |
22 protected: | 23 protected: |
23 void draw(const int loops, SkCanvas* canvas, SkImageFilter* imageFilter) con
st { | 24 void draw(const int loops, SkCanvas* canvas, SkImageFilter* imageFilter) con
st { |
24 SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_S
MALL) : | 25 SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_S
MALL) : |
25 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_L
ARGE); | 26 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_L
ARGE); |
26 SkPaint paint; | 27 SkPaint paint; |
27 paint.setImageFilter(imageFilter)->unref(); | 28 paint.setImageFilter(imageFilter)->unref(); |
28 for (int i = 0; i < loops; i++) { | 29 for (int i = 0; i < loops; i++) { |
29 canvas->drawRect(r, paint); | 30 canvas->drawRect(r, paint); |
30 } | 31 } |
31 } | 32 } |
32 | 33 |
33 static SkPoint3 getPointLocation() { | 34 static SkPoint3 GetPointLocation() { |
34 static SkPoint3 pointLocation(0, 0, SkIntToScalar(10)); | 35 static SkPoint3 pointLocation = SkPoint3::Make(0, 0, SkIntToScalar(10)); |
35 return pointLocation; | 36 return pointLocation; |
36 } | 37 } |
37 | 38 |
38 static SkPoint3 getDistantDirection() { | 39 static SkPoint3 GetDistantDirection() { |
39 static SkScalar azimuthRad = SkDegreesToRadians(SkIntToScalar(225)); | 40 static SkScalar azimuthRad = SkDegreesToRadians(SkIntToScalar(225)); |
40 static SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5)); | 41 static SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5)); |
41 static SkPoint3 distantDirection(SkScalarMul(SkScalarCos(azimuthRad), | 42 static SkPoint3 distantDirection = SkPoint3::Make(SkScalarMul(SkScalarCo
s(azimuthRad), |
42 SkScalarCos(elevationRad)), | 43 SkScalarCo
s(elevationRad)), |
43 SkScalarMul(SkScalarSin(azimuthRad), | 44 SkScalarMul(SkScalarSi
n(azimuthRad), |
44 SkScalarCos(elevationRad)), | 45 SkScalarCo
s(elevationRad)), |
45 SkScalarSin(elevationRad)); | 46 SkScalarSin(elevationR
ad)); |
46 return distantDirection; | 47 return distantDirection; |
47 } | 48 } |
48 | 49 |
49 static SkPoint3 getSpotLocation() { | 50 static SkPoint3 GetSpotLocation() { |
50 static SkPoint3 spotLocation(SkIntToScalar(-10), SkIntToScalar(-10), SkI
ntToScalar(20)); | 51 static SkPoint3 spotLocation = SkPoint3::Make(SkIntToScalar(-10), |
| 52 SkIntToScalar(-10), |
| 53 SkIntToScalar(20)); |
51 return spotLocation; | 54 return spotLocation; |
52 } | 55 } |
53 | 56 |
54 static SkPoint3 getSpotTarget() { | 57 static SkPoint3 GetSpotTarget() { |
55 static SkPoint3 spotTarget(SkIntToScalar(40), SkIntToScalar(40), 0); | 58 static SkPoint3 spotTarget = SkPoint3::Make(SkIntToScalar(40), SkIntToSc
alar(40), 0); |
56 return spotTarget; | 59 return spotTarget; |
57 } | 60 } |
58 | 61 |
59 static SkScalar getSpotExponent() { | 62 static SkScalar GetSpotExponent() { |
60 static SkScalar spotExponent = SK_Scalar1; | 63 static SkScalar spotExponent = SK_Scalar1; |
61 return spotExponent; | 64 return spotExponent; |
62 } | 65 } |
63 | 66 |
64 static SkScalar getCutoffAngle() { | 67 static SkScalar GetCutoffAngle() { |
65 static SkScalar cutoffAngle = SkIntToScalar(15); | 68 static SkScalar cutoffAngle = SkIntToScalar(15); |
66 return cutoffAngle; | 69 return cutoffAngle; |
67 } | 70 } |
68 | 71 |
69 static SkScalar getKd() { | 72 static SkScalar GetKd() { |
70 static SkScalar kd = SkIntToScalar(2); | 73 static SkScalar kd = SkIntToScalar(2); |
71 return kd; | 74 return kd; |
72 } | 75 } |
73 | 76 |
74 static SkScalar getKs() { | 77 static SkScalar GetKs() { |
75 static SkScalar ks = SkIntToScalar(1); | 78 static SkScalar ks = SkIntToScalar(1); |
76 return ks; | 79 return ks; |
77 } | 80 } |
78 | 81 |
79 static SkScalar getShininess() { | 82 static SkScalar GetShininess() { |
80 static SkScalar shininess = SkIntToScalar(8); | 83 static SkScalar shininess = SkIntToScalar(8); |
81 return shininess; | 84 return shininess; |
82 } | 85 } |
83 | 86 |
84 static SkScalar getSurfaceScale() { | 87 static SkScalar GetSurfaceScale() { |
85 static SkScalar surfaceScale = SkIntToScalar(1); | 88 static SkScalar surfaceScale = SkIntToScalar(1); |
86 return surfaceScale; | 89 return surfaceScale; |
87 } | 90 } |
88 | 91 |
89 static SkColor getWhite() { | 92 static SkColor GetWhite() { |
90 static SkColor white(0xFFFFFFFF); | 93 static SkColor white(0xFFFFFFFF); |
91 return white; | 94 return white; |
92 } | 95 } |
93 | 96 |
94 bool fIsSmall; | 97 bool fIsSmall; |
95 typedef Benchmark INHERITED; | 98 typedef Benchmark INHERITED; |
96 }; | 99 }; |
97 | 100 |
98 class LightingPointLitDiffuseBench : public LightingBaseBench { | 101 class LightingPointLitDiffuseBench : public LightingBaseBench { |
99 public: | 102 public: |
100 LightingPointLitDiffuseBench(bool small) : INHERITED(small) { | 103 LightingPointLitDiffuseBench(bool small) : INHERITED(small) { |
101 } | 104 } |
102 | 105 |
103 protected: | 106 protected: |
104 const char* onGetName() override { | 107 const char* onGetName() override { |
105 return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdif
fuse_large"; | 108 return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdif
fuse_large"; |
106 } | 109 } |
107 | 110 |
108 void onDraw(const int loops, SkCanvas* canvas) override { | 111 void onDraw(const int loops, SkCanvas* canvas) override { |
109 draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(getPoin
tLocation(), | 112 draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(GetPoin
tLocation(), |
110 getWhit
e(), | 113 GetWhit
e(), |
111 getSurf
aceScale(), | 114 GetSurf
aceScale(), |
112 getKd()
)); | 115 GetKd()
)); |
113 } | 116 } |
114 | 117 |
115 private: | 118 private: |
116 typedef LightingBaseBench INHERITED; | 119 typedef LightingBaseBench INHERITED; |
117 }; | 120 }; |
118 | 121 |
119 class LightingDistantLitDiffuseBench : public LightingBaseBench { | 122 class LightingDistantLitDiffuseBench : public LightingBaseBench { |
120 public: | 123 public: |
121 LightingDistantLitDiffuseBench(bool small) : INHERITED(small) { | 124 LightingDistantLitDiffuseBench(bool small) : INHERITED(small) { |
122 } | 125 } |
123 | 126 |
124 protected: | 127 protected: |
125 const char* onGetName() override { | 128 const char* onGetName() override { |
126 return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantli
tdiffuse_large"; | 129 return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantli
tdiffuse_large"; |
127 } | 130 } |
128 | 131 |
129 void onDraw(const int loops, SkCanvas* canvas) override { | 132 void onDraw(const int loops, SkCanvas* canvas) override { |
130 draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(getDi
stantDirection(), | 133 draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(GetDi
stantDirection(), |
131 getWh
ite(), | 134 GetWh
ite(), |
132 getSu
rfaceScale(), | 135 GetSu
rfaceScale(), |
133 getKd
())); | 136 GetKd
())); |
134 } | 137 } |
135 | 138 |
136 private: | 139 private: |
137 typedef LightingBaseBench INHERITED; | 140 typedef LightingBaseBench INHERITED; |
138 }; | 141 }; |
139 | 142 |
140 class LightingSpotLitDiffuseBench : public LightingBaseBench { | 143 class LightingSpotLitDiffuseBench : public LightingBaseBench { |
141 public: | 144 public: |
142 LightingSpotLitDiffuseBench(bool small) : INHERITED(small) { | 145 LightingSpotLitDiffuseBench(bool small) : INHERITED(small) { |
143 } | 146 } |
144 | 147 |
145 protected: | 148 protected: |
146 const char* onGetName() override { | 149 const char* onGetName() override { |
147 return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffu
se_large"; | 150 return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffu
se_large"; |
148 } | 151 } |
149 | 152 |
150 void onDraw(const int loops, SkCanvas* canvas) override { | 153 void onDraw(const int loops, SkCanvas* canvas) override { |
151 draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(getSpotL
ocation(), | 154 draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(GetSpotL
ocation(), |
152 getSpotT
arget(), | 155 GetSpotT
arget(), |
153 getSpotE
xponent(), | 156 GetSpotE
xponent(), |
154 getCutof
fAngle(), | 157 GetCutof
fAngle(), |
155 getWhite
(), | 158 GetWhite
(), |
156 getSurfa
ceScale(), | 159 GetSurfa
ceScale(), |
157 getKd())
); | 160 GetKd())
); |
158 } | 161 } |
159 | 162 |
160 private: | 163 private: |
161 typedef LightingBaseBench INHERITED; | 164 typedef LightingBaseBench INHERITED; |
162 }; | 165 }; |
163 | 166 |
164 class LightingPointLitSpecularBench : public LightingBaseBench { | 167 class LightingPointLitSpecularBench : public LightingBaseBench { |
165 public: | 168 public: |
166 LightingPointLitSpecularBench(bool small) : INHERITED(small) { | 169 LightingPointLitSpecularBench(bool small) : INHERITED(small) { |
167 } | 170 } |
168 | 171 |
169 protected: | 172 protected: |
170 const char* onGetName() override { | 173 const char* onGetName() override { |
171 return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitsp
ecular_large"; | 174 return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitsp
ecular_large"; |
172 } | 175 } |
173 | 176 |
174 void onDraw(const int loops, SkCanvas* canvas) override { | 177 void onDraw(const int loops, SkCanvas* canvas) override { |
175 draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(getPoi
ntLocation(), | 178 draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(GetPoi
ntLocation(), |
176 getWhi
te(), | 179 GetWhi
te(), |
177 getSur
faceScale(), | 180 GetSur
faceScale(), |
178 getKs(
), | 181 GetKs(
), |
179 getShi
niness())); | 182 GetShi
niness())); |
180 } | 183 } |
181 | 184 |
182 private: | 185 private: |
183 typedef LightingBaseBench INHERITED; | 186 typedef LightingBaseBench INHERITED; |
184 }; | 187 }; |
185 | 188 |
186 class LightingDistantLitSpecularBench : public LightingBaseBench { | 189 class LightingDistantLitSpecularBench : public LightingBaseBench { |
187 public: | 190 public: |
188 LightingDistantLitSpecularBench(bool small) : INHERITED(small) { | 191 LightingDistantLitSpecularBench(bool small) : INHERITED(small) { |
189 } | 192 } |
190 | 193 |
191 protected: | 194 protected: |
192 const char* onGetName() override { | 195 const char* onGetName() override { |
193 return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantl
itspecular_large"; | 196 return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantl
itspecular_large"; |
194 } | 197 } |
195 | 198 |
196 void onDraw(const int loops, SkCanvas* canvas) override { | 199 void onDraw(const int loops, SkCanvas* canvas) override { |
197 draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(getD
istantDirection(), | 200 draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(GetD
istantDirection(), |
198 getW
hite(), | 201 GetW
hite(), |
199 getS
urfaceScale(), | 202 GetS
urfaceScale(), |
200 getK
s(), | 203 GetK
s(), |
201 getS
hininess())); | 204 GetS
hininess())); |
202 } | 205 } |
203 | 206 |
204 private: | 207 private: |
205 typedef LightingBaseBench INHERITED; | 208 typedef LightingBaseBench INHERITED; |
206 }; | 209 }; |
207 | 210 |
208 class LightingSpotLitSpecularBench : public LightingBaseBench { | 211 class LightingSpotLitSpecularBench : public LightingBaseBench { |
209 public: | 212 public: |
210 LightingSpotLitSpecularBench(bool small) : INHERITED(small) { | 213 LightingSpotLitSpecularBench(bool small) : INHERITED(small) { |
211 } | 214 } |
212 | 215 |
213 protected: | 216 protected: |
214 const char* onGetName() override { | 217 const char* onGetName() override { |
215 return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspec
ular_large"; | 218 return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspec
ular_large"; |
216 } | 219 } |
217 | 220 |
218 void onDraw(const int loops, SkCanvas* canvas) override { | 221 void onDraw(const int loops, SkCanvas* canvas) override { |
219 draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(getSpot
Location(), | 222 draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(GetSpot
Location(), |
220 getSpot
Target(), | 223 GetSpot
Target(), |
221 getSpot
Exponent(), | 224 GetSpot
Exponent(), |
222 getCuto
ffAngle(), | 225 GetCuto
ffAngle(), |
223 getWhit
e(), | 226 GetWhit
e(), |
224 getSurf
aceScale(), | 227 GetSurf
aceScale(), |
225 getKs()
, | 228 GetKs()
, |
226 getShin
iness())); | 229 GetShin
iness())); |
227 } | 230 } |
228 | 231 |
229 private: | 232 private: |
230 typedef LightingBaseBench INHERITED; | 233 typedef LightingBaseBench INHERITED; |
231 }; | 234 }; |
232 | 235 |
233 /////////////////////////////////////////////////////////////////////////////// | 236 /////////////////////////////////////////////////////////////////////////////// |
234 | 237 |
235 DEF_BENCH( return new LightingPointLitDiffuseBench(true); ) | 238 DEF_BENCH( return new LightingPointLitDiffuseBench(true); ) |
236 DEF_BENCH( return new LightingPointLitDiffuseBench(false); ) | 239 DEF_BENCH( return new LightingPointLitDiffuseBench(false); ) |
237 DEF_BENCH( return new LightingDistantLitDiffuseBench(true); ) | 240 DEF_BENCH( return new LightingDistantLitDiffuseBench(true); ) |
238 DEF_BENCH( return new LightingDistantLitDiffuseBench(false); ) | 241 DEF_BENCH( return new LightingDistantLitDiffuseBench(false); ) |
239 DEF_BENCH( return new LightingSpotLitDiffuseBench(true); ) | 242 DEF_BENCH( return new LightingSpotLitDiffuseBench(true); ) |
240 DEF_BENCH( return new LightingSpotLitDiffuseBench(false); ) | 243 DEF_BENCH( return new LightingSpotLitDiffuseBench(false); ) |
241 DEF_BENCH( return new LightingPointLitSpecularBench(true); ) | 244 DEF_BENCH( return new LightingPointLitSpecularBench(true); ) |
242 DEF_BENCH( return new LightingPointLitSpecularBench(false); ) | 245 DEF_BENCH( return new LightingPointLitSpecularBench(false); ) |
243 DEF_BENCH( return new LightingDistantLitSpecularBench(true); ) | 246 DEF_BENCH( return new LightingDistantLitSpecularBench(true); ) |
244 DEF_BENCH( return new LightingDistantLitSpecularBench(false); ) | 247 DEF_BENCH( return new LightingDistantLitSpecularBench(false); ) |
245 DEF_BENCH( return new LightingSpotLitSpecularBench(true); ) | 248 DEF_BENCH( return new LightingSpotLitSpecularBench(true); ) |
246 DEF_BENCH( return new LightingSpotLitSpecularBench(false); ) | 249 DEF_BENCH( return new LightingSpotLitSpecularBench(false); ) |
OLD | NEW |