OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2013 Google Inc. | 3 * Copyright 2013 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "gm.h" | 9 #include "gm.h" |
10 #include "SkTArray.h" | 10 #include "SkTArray.h" |
11 #include "SkRandom.h" | 11 #include "SkRandom.h" |
12 #include "SkMatrix.h" | 12 #include "SkMatrix.h" |
13 #include "SkBlurMaskFilter.h" | 13 #include "SkBlurMaskFilter.h" |
14 #include "SkGradientShader.h" | 14 #include "SkGradientShader.h" |
15 #include "SkBlurDrawLooper.h" | 15 #include "SkBlurDrawLooper.h" |
16 #include "SkRect.h" | 16 #include "SkRect.h" |
17 #include "SkRRect.h" | 17 #include "SkRRect.h" |
18 | 18 |
19 namespace skiagm { | 19 namespace skiagm { |
20 | 20 |
| 21 static SkColor gen_color(SkRandom* rand) { |
| 22 SkScalar hsv[3]; |
| 23 hsv[0] = rand->nextRangeF(0.0f, 360.0f); |
| 24 hsv[1] = rand->nextRangeF(0.75f, 1.0f); |
| 25 hsv[2] = rand->nextRangeF(0.75f, 1.0f); |
| 26 |
| 27 return sk_tool_utils::color_to_565(SkHSVToColor(hsv)); |
| 28 } |
| 29 |
21 class RoundRectGM : public GM { | 30 class RoundRectGM : public GM { |
22 public: | 31 public: |
23 RoundRectGM() { | 32 RoundRectGM() { |
24 this->setBGColor(0xFF000000); | 33 this->setBGColor(0xFF000000); |
25 this->makePaints(); | 34 this->makePaints(); |
26 this->makeMatrices(); | 35 this->makeMatrices(); |
27 } | 36 } |
28 | 37 |
29 protected: | 38 protected: |
30 | 39 |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
120 fMatrices.push_back(m); | 129 fMatrices.push_back(m); |
121 } | 130 } |
122 | 131 |
123 { | 132 { |
124 SkMatrix m; | 133 SkMatrix m; |
125 m.setRotate(SkIntToScalar(60)); | 134 m.setRotate(SkIntToScalar(60)); |
126 fMatrices.push_back(m); | 135 fMatrices.push_back(m); |
127 } | 136 } |
128 } | 137 } |
129 | 138 |
130 SkColor genColor(SkRandom* rand) { | |
131 SkScalar hsv[3]; | |
132 hsv[0] = rand->nextRangeF(0.0f, 360.0f); | |
133 hsv[1] = rand->nextRangeF(0.75f, 1.0f); | |
134 hsv[2] = rand->nextRangeF(0.75f, 1.0f); | |
135 | |
136 return sk_tool_utils::color_to_565(SkHSVToColor(hsv)); | |
137 } | |
138 | |
139 void onDraw(SkCanvas* canvas) override { | 139 void onDraw(SkCanvas* canvas) override { |
140 SkRandom rand(1); | 140 SkRandom rand(1); |
141 canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1); | 141 canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1); |
142 SkRect rect = SkRect::MakeLTRB(-20, -30, 20, 30); | 142 const SkRect rect = SkRect::MakeLTRB(-20, -30, 20, 30); |
143 SkRRect circleRect; | 143 SkRRect circleRect; |
144 circleRect.setRectXY(rect, 5, 5); | 144 circleRect.setRectXY(rect, 5, 5); |
145 | 145 |
146 const SkScalar kXStart = 60.0f; | 146 const SkScalar kXStart = 60.0f; |
147 const SkScalar kYStart = 80.0f; | 147 const SkScalar kYStart = 80.0f; |
148 const int kXStep = 150; | 148 const int kXStep = 150; |
149 const int kYStep = 160; | 149 const int kYStep = 160; |
150 int maxX = fMatrices.count(); | 150 int maxX = fMatrices.count(); |
151 | 151 |
152 SkPaint rectPaint; | 152 SkPaint rectPaint; |
153 rectPaint.setAntiAlias(true); | 153 rectPaint.setAntiAlias(true); |
154 rectPaint.setStyle(SkPaint::kStroke_Style); | 154 rectPaint.setStyle(SkPaint::kStroke_Style); |
155 rectPaint.setStrokeWidth(SkIntToScalar(0)); | 155 rectPaint.setStrokeWidth(SkIntToScalar(0)); |
156 rectPaint.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY)); | 156 rectPaint.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY)); |
157 | 157 |
158 int testCount = 0; | 158 int testCount = 0; |
159 for (int i = 0; i < fPaints.count(); ++i) { | 159 for (int i = 0; i < fPaints.count(); ++i) { |
160 for (int j = 0; j < fMatrices.count(); ++j) { | 160 for (int j = 0; j < fMatrices.count(); ++j) { |
161 canvas->save(); | 161 canvas->save(); |
162 SkMatrix mat = fMatrices[j]; | 162 SkMatrix mat = fMatrices[j]; |
163 // position the roundrect, and make it at off-integer coords. | 163 // position the roundrect, and make it at off-integer coords. |
164 mat.postTranslate(kXStart + SK_Scalar1 * kXStep * (testCount % m
axX) + | 164 mat.postTranslate(kXStart + SK_Scalar1 * kXStep * (testCount % m
axX) + |
165 SK_Scalar1 / 4, | 165 SK_Scalar1 / 4, |
166 kYStart + SK_Scalar1 * kYStep * (testCount / m
axX) + | 166 kYStart + SK_Scalar1 * kYStep * (testCount / m
axX) + |
167 3 * SK_Scalar1 / 4); | 167 3 * SK_Scalar1 / 4); |
168 canvas->concat(mat); | 168 canvas->concat(mat); |
169 | 169 |
170 SkColor color = genColor(&rand); | 170 SkColor color = gen_color(&rand); |
171 fPaints[i].setColor(color); | 171 fPaints[i].setColor(color); |
172 | 172 |
173 canvas->drawRect(rect, rectPaint); | 173 canvas->drawRect(rect, rectPaint); |
174 canvas->drawRRect(circleRect, fPaints[i]); | 174 canvas->drawRRect(circleRect, fPaints[i]); |
175 | 175 |
176 canvas->restore(); | 176 canvas->restore(); |
177 | 177 |
178 ++testCount; | 178 ++testCount; |
179 } | 179 } |
180 } | 180 } |
181 | 181 |
182 // special cases | 182 // special cases |
183 | 183 |
184 // non-scaled tall and skinny roundrect | 184 // non-scaled tall and skinny roundrect |
185 for (int i = 0; i < fPaints.count(); ++i) { | 185 for (int i = 0; i < fPaints.count(); ++i) { |
186 SkRect rect = SkRect::MakeLTRB(-20, -60, 20, 60); | 186 SkRect rect = SkRect::MakeLTRB(-20, -60, 20, 60); |
187 SkRRect ellipseRect; | 187 SkRRect ellipseRect; |
188 ellipseRect.setRectXY(rect, 5, 10); | 188 ellipseRect.setRectXY(rect, 5, 10); |
189 | 189 |
190 canvas->save(); | 190 canvas->save(); |
191 // position the roundrect, and make it at off-integer coords. | 191 // position the roundrect, and make it at off-integer coords. |
192 canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.55f + SK_Scalar1
/ 4, | 192 canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.55f + SK_Scalar1
/ 4, |
193 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4); | 193 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4); |
194 | 194 |
195 SkColor color = genColor(&rand); | 195 SkColor color = gen_color(&rand); |
196 fPaints[i].setColor(color); | 196 fPaints[i].setColor(color); |
197 | 197 |
198 canvas->drawRect(rect, rectPaint); | 198 canvas->drawRect(rect, rectPaint); |
199 canvas->drawRRect(ellipseRect, fPaints[i]); | 199 canvas->drawRRect(ellipseRect, fPaints[i]); |
200 canvas->restore(); | 200 canvas->restore(); |
201 } | 201 } |
202 | 202 |
203 // non-scaled wide and short roundrect | 203 // non-scaled wide and short roundrect |
204 for (int i = 0; i < fPaints.count(); ++i) { | 204 for (int i = 0; i < fPaints.count(); ++i) { |
205 SkRect rect = SkRect::MakeLTRB(-80, -30, 80, 30); | 205 SkRect rect = SkRect::MakeLTRB(-80, -30, 80, 30); |
206 SkRRect ellipseRect; | 206 SkRRect ellipseRect; |
207 ellipseRect.setRectXY(rect, 20, 5); | 207 ellipseRect.setRectXY(rect, 20, 5); |
208 | 208 |
209 canvas->save(); | 209 canvas->save(); |
210 // position the roundrect, and make it at off-integer coords. | 210 // position the roundrect, and make it at off-integer coords. |
211 canvas->translate(kXStart + SK_Scalar1 * kXStep * 4 + SK_Scalar1 / 4
, | 211 canvas->translate(kXStart + SK_Scalar1 * kXStep * 4 + SK_Scalar1 / 4
, |
212 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + | 212 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + |
213 SK_ScalarHalf * kYStep); | 213 SK_ScalarHalf * kYStep); |
214 | 214 |
215 SkColor color = genColor(&rand); | 215 SkColor color = gen_color(&rand); |
216 fPaints[i].setColor(color); | 216 fPaints[i].setColor(color); |
217 | 217 |
218 canvas->drawRect(rect, rectPaint); | 218 canvas->drawRect(rect, rectPaint); |
219 canvas->drawRRect(ellipseRect, fPaints[i]); | 219 canvas->drawRRect(ellipseRect, fPaints[i]); |
220 canvas->restore(); | 220 canvas->restore(); |
221 } | 221 } |
222 | 222 |
223 // super skinny roundrect | 223 // super skinny roundrect |
224 for (int i = 0; i < fPaints.count(); ++i) { | 224 for (int i = 0; i < fPaints.count(); ++i) { |
225 SkRect rect = SkRect::MakeLTRB(0, -60, 1, 60); | 225 SkRect rect = SkRect::MakeLTRB(0, -60, 1, 60); |
226 SkRRect circleRect; | 226 SkRRect circleRect; |
227 circleRect.setRectXY(rect, 5, 5); | 227 circleRect.setRectXY(rect, 5, 5); |
228 | 228 |
229 canvas->save(); | 229 canvas->save(); |
230 // position the roundrect, and make it at off-integer coords. | 230 // position the roundrect, and make it at off-integer coords. |
231 canvas->translate(kXStart + SK_Scalar1 * kXStep * 3.25f + SK_Scalar1
/ 4, | 231 canvas->translate(kXStart + SK_Scalar1 * kXStep * 3.25f + SK_Scalar1
/ 4, |
232 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4); | 232 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4); |
233 | 233 |
234 SkColor color = genColor(&rand); | 234 SkColor color = gen_color(&rand); |
235 fPaints[i].setColor(color); | 235 fPaints[i].setColor(color); |
236 | 236 |
237 canvas->drawRRect(circleRect, fPaints[i]); | 237 canvas->drawRRect(circleRect, fPaints[i]); |
238 canvas->restore(); | 238 canvas->restore(); |
239 } | 239 } |
240 | 240 |
241 // super short roundrect | 241 // super short roundrect |
242 for (int i = 0; i < fPaints.count(); ++i) { | 242 for (int i = 0; i < fPaints.count(); ++i) { |
243 SkRect rect = SkRect::MakeLTRB(-80, -1, 80, 0); | 243 SkRect rect = SkRect::MakeLTRB(-80, -1, 80, 0); |
244 SkRRect circleRect; | 244 SkRRect circleRect; |
245 circleRect.setRectXY(rect, 5, 5); | 245 circleRect.setRectXY(rect, 5, 5); |
246 | 246 |
247 canvas->save(); | 247 canvas->save(); |
248 // position the roundrect, and make it at off-integer coords. | 248 // position the roundrect, and make it at off-integer coords. |
249 canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.5f + SK_Scalar1
/ 4, | 249 canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.5f + SK_Scalar1
/ 4, |
250 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + | 250 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + |
251 SK_ScalarHalf * kYStep); | 251 SK_ScalarHalf * kYStep); |
252 | 252 |
253 SkColor color = genColor(&rand); | 253 SkColor color = gen_color(&rand); |
254 fPaints[i].setColor(color); | 254 fPaints[i].setColor(color); |
255 | 255 |
256 canvas->drawRRect(circleRect, fPaints[i]); | 256 canvas->drawRRect(circleRect, fPaints[i]); |
257 canvas->restore(); | 257 canvas->restore(); |
258 } | 258 } |
259 | 259 |
260 // radial gradient | 260 // radial gradient |
261 SkPoint center = SkPoint::Make(SkIntToScalar(0), SkIntToScalar(0)); | 261 SkPoint center = SkPoint::Make(SkIntToScalar(0), SkIntToScalar(0)); |
262 SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN }; | 262 SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN }; |
263 SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 }; | 263 SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 }; |
264 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, | 264 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, |
265 SkIntToScalar(20), | 265 SkIntToScalar(20), |
266 colors, | 266 colors, |
267 pos, | 267 pos, |
268 SK_ARRAY_COUNT(colors), | 268 SK_ARRAY_COUNT(colors), |
269 SkShader::kClamp_TileMode))
; | 269 SkShader::kClamp_TileMode))
; |
270 | 270 |
271 for (int i = 0; i < fPaints.count(); ++i) { | 271 for (int i = 0; i < fPaints.count(); ++i) { |
272 canvas->save(); | 272 canvas->save(); |
273 // position the path, and make it at off-integer coords. | 273 // position the path, and make it at off-integer coords. |
274 canvas->translate(kXStart + SK_Scalar1 * kXStep * 0 + SK_Scalar1 / 4
, | 274 canvas->translate(kXStart + SK_Scalar1 * kXStep * 0 + SK_Scalar1 / 4
, |
275 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + | 275 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1
/ 4 + |
276 SK_ScalarHalf * kYStep); | 276 SK_ScalarHalf * kYStep); |
277 | 277 |
278 SkColor color = genColor(&rand); | 278 SkColor color = gen_color(&rand); |
279 fPaints[i].setColor(color); | 279 fPaints[i].setColor(color); |
280 fPaints[i].setShader(shader); | 280 fPaints[i].setShader(shader); |
281 | 281 |
282 canvas->drawRect(rect, rectPaint); | 282 canvas->drawRect(rect, rectPaint); |
283 canvas->drawRRect(circleRect, fPaints[i]); | 283 canvas->drawRRect(circleRect, fPaints[i]); |
284 | 284 |
285 fPaints[i].setShader(nullptr); | 285 fPaints[i].setShader(nullptr); |
286 | 286 |
287 canvas->restore(); | 287 canvas->restore(); |
288 } | 288 } |
(...skipping 14 matching lines...) Expand all Loading... |
303 for (int i = 0; i < 4; ++i) { | 303 for (int i = 0; i < 4; ++i) { |
304 SkRRect circleRect; | 304 SkRRect circleRect; |
305 circleRect.setRectXY(rect, radii[i][0], radii[i][1]); | 305 circleRect.setRectXY(rect, radii[i][0], radii[i][1]); |
306 | 306 |
307 canvas->save(); | 307 canvas->save(); |
308 // position the roundrect, and make it at off-integer coords. | 308 // position the roundrect, and make it at off-integer coords. |
309 canvas->translate(kXStart + SK_Scalar1 * kXStep * 5 + SK_Scalar1
/ 4, | 309 canvas->translate(kXStart + SK_Scalar1 * kXStep * 5 + SK_Scalar1
/ 4, |
310 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Sca
lar1 / 4 + | 310 kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Sca
lar1 / 4 + |
311 SK_ScalarHalf * kYStep); | 311 SK_ScalarHalf * kYStep); |
312 | 312 |
313 SkColor color = genColor(&rand); | 313 SkColor color = gen_color(&rand); |
314 | 314 |
315 SkPaint p; | 315 SkPaint p; |
316 p.setAntiAlias(true); | 316 p.setAntiAlias(true); |
317 p.setStyle(SkPaint::kStroke_Style); | 317 p.setStyle(SkPaint::kStroke_Style); |
318 p.setStrokeWidth(strokeWidths[i]); | 318 p.setStrokeWidth(strokeWidths[i]); |
319 p.setColor(color); | 319 p.setColor(color); |
320 | 320 |
321 canvas->drawRRect(circleRect, p); | 321 canvas->drawRRect(circleRect, p); |
322 canvas->restore(); | 322 canvas->restore(); |
323 } | 323 } |
324 } | 324 } |
325 | 325 |
| 326 // test old entry point (skbug.com/3786) |
| 327 { |
| 328 canvas->save(); |
| 329 |
| 330 canvas->translate(kXStart + SK_Scalar1 * kXStep * 5 + SK_Scalar1 / 4
, |
| 331 kYStart + SK_Scalar1 * kYStep * 4 + SK_Scalar1 / 4
+ |
| 332 SK_ScalarHalf * kYStep); |
| 333 |
| 334 const SkColor color = gen_color(&rand); |
| 335 |
| 336 SkPaint p; |
| 337 p.setColor(color); |
| 338 |
| 339 const SkRect oooRect = { 20, 30, -20, -30 }; // intentionally ou
t of order |
| 340 canvas->drawRoundRect(oooRect, 10, 10, p); |
| 341 |
| 342 canvas->restore(); |
| 343 } |
326 } | 344 } |
327 | 345 |
328 private: | 346 private: |
329 SkTArray<SkPaint> fPaints; | 347 SkTArray<SkPaint> fPaints; |
330 SkTArray<SkMatrix> fMatrices; | 348 SkTArray<SkMatrix> fMatrices; |
331 | 349 |
332 typedef GM INHERITED; | 350 typedef GM INHERITED; |
333 }; | 351 }; |
334 | 352 |
335 ////////////////////////////////////////////////////////////////////////////// | 353 ////////////////////////////////////////////////////////////////////////////// |
336 | 354 |
337 static GM* MyFactory(void*) { return new RoundRectGM; } | 355 static GM* MyFactory(void*) { return new RoundRectGM; } |
338 static GMRegistry reg(MyFactory); | 356 static GMRegistry reg(MyFactory); |
339 | 357 |
340 } | 358 } |
OLD | NEW |