• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /*
3  * Copyright 2013 Google Inc.
4  *
5  * Use of this source code is governed by a BSD-style license that can be
6  * found in the LICENSE file.
7  */
8 
9 #include "gm.h"
10 #include "SkTArray.h"
11 #include "SkRandom.h"
12 #include "SkMatrix.h"
13 #include "SkBlurMaskFilter.h"
14 #include "SkGradientShader.h"
15 #include "SkBlurDrawLooper.h"
16 #include "SkRect.h"
17 
18 namespace skiagm {
19 
20 class OvalGM : public GM {
21 public:
OvalGM()22     OvalGM() {
23         this->setBGColor(0xFF000000);
24         this->makePaints();
25         this->makeMatrices();
26     }
27 
28 protected:
onGetFlags() const29     virtual uint32_t onGetFlags() const SK_OVERRIDE {
30         return kSkipTiled_Flag;
31     }
32 
onShortName()33     virtual SkString onShortName() SK_OVERRIDE {
34         return SkString("ovals");
35     }
36 
onISize()37     virtual SkISize onISize() SK_OVERRIDE {
38         return SkISize::Make(1200, 900);
39     }
40 
makePaints()41     void makePaints() {
42         {
43         // no AA
44         SkPaint p;
45         fPaints.push_back(p);
46         }
47 
48         {
49         // AA
50         SkPaint p;
51         p.setAntiAlias(true);
52         fPaints.push_back(p);
53         }
54 
55         {
56         // AA with stroke style
57         SkPaint p;
58         p.setAntiAlias(true);
59         p.setStyle(SkPaint::kStroke_Style);
60         p.setStrokeWidth(SkIntToScalar(5));
61         fPaints.push_back(p);
62         }
63 
64         {
65         // AA with stroke style, width = 0
66         SkPaint p;
67         p.setAntiAlias(true);
68         p.setStyle(SkPaint::kStroke_Style);
69         fPaints.push_back(p);
70         }
71 
72         {
73         // AA with stroke and fill style
74         SkPaint p;
75         p.setAntiAlias(true);
76         p.setStyle(SkPaint::kStrokeAndFill_Style);
77         p.setStrokeWidth(SkIntToScalar(3));
78         fPaints.push_back(p);
79         }
80     }
81 
makeMatrices()82     void makeMatrices() {
83         {
84         SkMatrix m;
85         m.setIdentity();
86         fMatrices.push_back(m);
87         }
88 
89         {
90         SkMatrix m;
91         m.setScale(SkIntToScalar(3), SkIntToScalar(2));
92         fMatrices.push_back(m);
93         }
94 
95         {
96         SkMatrix m;
97         m.setScale(SkIntToScalar(2), SkIntToScalar(2));
98         fMatrices.push_back(m);
99         }
100 
101         {
102         SkMatrix m;
103         m.setScale(SkIntToScalar(1), SkIntToScalar(2));
104         fMatrices.push_back(m);
105         }
106 
107         {
108         SkMatrix m;
109         m.setScale(SkIntToScalar(4), SkIntToScalar(1));
110         fMatrices.push_back(m);
111         }
112 
113         {
114         SkMatrix m;
115         m.setRotate(SkIntToScalar(90));
116         fMatrices.push_back(m);
117         }
118 
119         {
120         SkMatrix m;
121         m.setSkew(SkIntToScalar(2), SkIntToScalar(3));
122         fMatrices.push_back(m);
123         }
124 
125         {
126         SkMatrix m;
127         m.setRotate(SkIntToScalar(60));
128         fMatrices.push_back(m);
129         }
130     }
131 
genColor(SkRandom * rand)132     SkColor genColor(SkRandom* rand) {
133         SkScalar hsv[3];
134         hsv[0] = rand->nextRangeF(0.0f, 360.0f);
135         hsv[1] = rand->nextRangeF(0.75f, 1.0f);
136         hsv[2] = rand->nextRangeF(0.75f, 1.0f);
137 
138         return SkHSVToColor(hsv);
139     }
140 
onDraw(SkCanvas * canvas)141     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
142         SkRandom rand(1);
143         canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1);
144         SkRect oval = SkRect::MakeLTRB(-20, -30, 20, 30);
145 
146         const SkScalar kXStart = 60.0f;
147         const SkScalar kYStart = 80.0f;
148         const int kXStep = 150;
149         const int kYStep = 160;
150         int maxX = fMatrices.count();
151 
152         SkPaint rectPaint;
153         rectPaint.setAntiAlias(true);
154         rectPaint.setStyle(SkPaint::kStroke_Style);
155         rectPaint.setStrokeWidth(SkIntToScalar(0));
156         rectPaint.setColor(SK_ColorLTGRAY);
157 
158         int testCount = 0;
159         for (int i = 0; i < fPaints.count(); ++i) {
160             for (int j = 0; j < fMatrices.count(); ++j) {
161                 canvas->save();
162                 SkMatrix mat = fMatrices[j];
163                 // position the oval, and make it at off-integer coords.
164                 mat.postTranslate(kXStart + SK_Scalar1 * kXStep * (testCount % maxX) +
165                                   SK_Scalar1 / 4,
166                                   kYStart + SK_Scalar1 * kYStep * (testCount / maxX) +
167                                   3 * SK_Scalar1 / 4);
168                 canvas->concat(mat);
169 
170                 SkColor color = genColor(&rand);
171                 fPaints[i].setColor(color);
172 
173                 canvas->drawRect(oval, rectPaint);
174                 canvas->drawOval(oval, fPaints[i]);
175 
176                 canvas->restore();
177 
178                 ++testCount;
179             }
180         }
181 
182         // special cases
183 
184         // non-scaled tall and skinny oval
185         for (int i = 0; i < fPaints.count(); ++i) {
186             SkRect oval = SkRect::MakeLTRB(-20, -60, 20, 60);
187             canvas->save();
188             // position the oval, and make it at off-integer coords.
189             canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.55f + SK_Scalar1 / 4,
190                               kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1 / 4);
191 
192             SkColor color = genColor(&rand);
193             fPaints[i].setColor(color);
194 
195             canvas->drawRect(oval, rectPaint);
196             canvas->drawOval(oval, fPaints[i]);
197             canvas->restore();
198         }
199 
200         // non-scaled wide and short oval
201         for (int i = 0; i < fPaints.count(); ++i) {
202             SkRect oval = SkRect::MakeLTRB(-80, -30, 80, 30);
203             canvas->save();
204             // position the oval, and make it at off-integer coords.
205             canvas->translate(kXStart + SK_Scalar1 * kXStep * 4 + SK_Scalar1 / 4,
206                               kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1 / 4 +
207                               SK_ScalarHalf * kYStep);
208 
209             SkColor color = genColor(&rand);
210             fPaints[i].setColor(color);
211 
212             canvas->drawRect(oval, rectPaint);
213             canvas->drawOval(oval, fPaints[i]);
214             canvas->restore();
215         }
216 
217         // super skinny oval
218         for (int i = 0; i < fPaints.count(); ++i) {
219             SkRect oval = SkRect::MakeLTRB(0, -60, 1, 60);
220             canvas->save();
221             // position the oval, and make it at off-integer coords.
222             canvas->translate(kXStart + SK_Scalar1 * kXStep * 3.25f + SK_Scalar1 / 4,
223                               kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1 / 4);
224 
225             SkColor color = genColor(&rand);
226             fPaints[i].setColor(color);
227 
228             canvas->drawOval(oval, fPaints[i]);
229             canvas->restore();
230         }
231 
232         // super short oval
233         for (int i = 0; i < fPaints.count(); ++i) {
234             SkRect oval = SkRect::MakeLTRB(-80, -1, 80, 0);
235             canvas->save();
236             // position the oval, and make it at off-integer coords.
237             canvas->translate(kXStart + SK_Scalar1 * kXStep * 2.5f + SK_Scalar1 / 4,
238                               kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1 / 4 +
239                               SK_ScalarHalf * kYStep);
240 
241             SkColor color = genColor(&rand);
242             fPaints[i].setColor(color);
243 
244             canvas->drawOval(oval, fPaints[i]);
245             canvas->restore();
246         }
247 
248         // radial gradient
249         SkPoint center = SkPoint::Make(SkIntToScalar(0), SkIntToScalar(0));
250         SkColor colors[] = { SK_ColorBLUE, SK_ColorRED, SK_ColorGREEN };
251         SkScalar pos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
252         SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center,
253                                                      SkIntToScalar(20),
254                                                      colors,
255                                                      pos,
256                                                      SK_ARRAY_COUNT(colors),
257                                                      SkShader::kClamp_TileMode));
258 
259         for (int i = 0; i < fPaints.count(); ++i) {
260             canvas->save();
261             // position the path, and make it at off-integer coords.
262             canvas->translate(kXStart + SK_Scalar1 * kXStep * 0 + SK_Scalar1 / 4,
263                               kYStart + SK_Scalar1 * kYStep * i + 3 * SK_Scalar1 / 4 +
264                               SK_ScalarHalf * kYStep);
265 
266             SkColor color = genColor(&rand);
267             fPaints[i].setColor(color);
268             fPaints[i].setShader(shader);
269 
270             canvas->drawRect(oval, rectPaint);
271             canvas->drawOval(oval, fPaints[i]);
272 
273             fPaints[i].setShader(NULL);
274 
275             canvas->restore();
276         }
277     }
278 
279 private:
280     SkTArray<SkPaint> fPaints;
281     SkTArray<SkMatrix> fMatrices;
282 
283     typedef GM INHERITED;
284 };
285 
286 //////////////////////////////////////////////////////////////////////////////
287 
MyFactory(void *)288 static GM* MyFactory(void*) { return new OvalGM; }
289 static GMRegistry reg(MyFactory);
290 
291 }
292