1 /*
2 * Copyright 2011 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 "SampleCode.h"
8 #include "SkBlurMask.h"
9 #include "SkBlurMaskFilter.h"
10 #include "SkCanvas.h"
11 #include "SkReadBuffer.h"
12 #include "SkWriteBuffer.h"
13 #include "SkGradientShader.h"
14 #include "SkLayerRasterizer.h"
15 #include "SkPaint.h"
16 #include "SkView.h"
17
18 #include "sk_tool_utils.h"
19
20 #define BG_COLOR 0xFFDDDDDD
21
22 typedef void (*SlideProc)(SkCanvas*);
23
24 ///////////////////////////////////////////////////////////////////////////////
25
26 #include "Sk1DPathEffect.h"
27 #include "Sk2DPathEffect.h"
28 #include "SkCornerPathEffect.h"
29 #include "SkDashPathEffect.h"
30 #include "SkDiscretePathEffect.h"
31
compose_pe(SkPaint * paint)32 static void compose_pe(SkPaint* paint) {
33 SkPathEffect* pe = paint->getPathEffect();
34 sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
35 sk_sp<SkPathEffect> compose;
36 if (pe) {
37 compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
38 } else {
39 compose = corner;
40 }
41 paint->setPathEffect(compose);
42 }
43
hair_pe(SkPaint * paint)44 static void hair_pe(SkPaint* paint) {
45 paint->setStrokeWidth(0);
46 }
47
hair2_pe(SkPaint * paint)48 static void hair2_pe(SkPaint* paint) {
49 paint->setStrokeWidth(0);
50 compose_pe(paint);
51 }
52
stroke_pe(SkPaint * paint)53 static void stroke_pe(SkPaint* paint) {
54 paint->setStrokeWidth(12);
55 compose_pe(paint);
56 }
57
dash_pe(SkPaint * paint)58 static void dash_pe(SkPaint* paint) {
59 SkScalar inter[] = { 20, 10, 10, 10 };
60 paint->setStrokeWidth(12);
61 paint->setPathEffect(SkDashPathEffect::Make(inter, SK_ARRAY_COUNT(inter), 0));
62 compose_pe(paint);
63 }
64
65 static const int gXY[] = {
66 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
67 };
68
scale(SkPath * path,SkScalar scale)69 static void scale(SkPath* path, SkScalar scale) {
70 SkMatrix m;
71 m.setScale(scale, scale);
72 path->transform(m);
73 }
74
one_d_pe(SkPaint * paint)75 static void one_d_pe(SkPaint* paint) {
76 SkPath path;
77 path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
78 for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
79 path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
80 path.close();
81 path.offset(SkIntToScalar(-6), 0);
82 scale(&path, 1.5f);
83
84 paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0,
85 SkPath1DPathEffect::kRotate_Style));
86 compose_pe(paint);
87 }
88
89 typedef void (*PE_Proc)(SkPaint*);
90 static const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
91
fill_pe(SkPaint * paint)92 static void fill_pe(SkPaint* paint) {
93 paint->setStyle(SkPaint::kFill_Style);
94 paint->setPathEffect(nullptr);
95 }
96
discrete_pe(SkPaint * paint)97 static void discrete_pe(SkPaint* paint) {
98 paint->setPathEffect(SkDiscretePathEffect::Make(10, 4));
99 }
100
MakeTileEffect()101 static sk_sp<SkPathEffect> MakeTileEffect() {
102 SkMatrix m;
103 m.setScale(SkIntToScalar(12), SkIntToScalar(12));
104
105 SkPath path;
106 path.addCircle(0, 0, SkIntToScalar(5));
107
108 return SkPath2DPathEffect::Make(m, path);
109 }
110
tile_pe(SkPaint * paint)111 static void tile_pe(SkPaint* paint) {
112 paint->setPathEffect(MakeTileEffect());
113 }
114
115 static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe };
116
patheffect_slide(SkCanvas * canvas)117 static void patheffect_slide(SkCanvas* canvas) {
118 SkPaint paint;
119 paint.setAntiAlias(true);
120 paint.setStyle(SkPaint::kStroke_Style);
121
122 SkPath path;
123 path.moveTo(20, 20);
124 path.lineTo(70, 120);
125 path.lineTo(120, 30);
126 path.lineTo(170, 80);
127 path.lineTo(240, 50);
128
129 size_t i;
130 canvas->save();
131 for (i = 0; i < SK_ARRAY_COUNT(gPE); i++) {
132 gPE[i](&paint);
133 canvas->drawPath(path, paint);
134 canvas->translate(0, 75);
135 }
136 canvas->restore();
137
138 path.reset();
139 SkRect r = { 0, 0, 250, 120 };
140 path.addOval(r, SkPath::kCW_Direction);
141 r.inset(50, 50);
142 path.addRect(r, SkPath::kCCW_Direction);
143
144 canvas->translate(320, 20);
145 for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
146 gPE2[i](&paint);
147 canvas->drawPath(path, paint);
148 canvas->translate(0, 160);
149 }
150 }
151
152 ///////////////////////////////////////////////////////////////////////////////
153
154 #include "SkGradientShader.h"
155
156 struct GradData {
157 int fCount;
158 const SkColor* fColors;
159 const SkScalar* fPos;
160 };
161
162 static const SkColor gColors[] = {
163 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
164 };
165 static const SkScalar gPos0[] = { 0, SK_Scalar1 };
166 static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
167 static const SkScalar gPos2[] = {
168 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
169 };
170
171 static const GradData gGradData[] = {
172 { 2, gColors, nullptr },
173 { 2, gColors, gPos0 },
174 { 2, gColors, gPos1 },
175 { 5, gColors, nullptr },
176 { 5, gColors, gPos2 }
177 };
178
MakeLinear(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm)179 static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
180 return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
181 }
182
MakeRadial(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm)183 static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
184 SkPoint center;
185 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
186 SkScalarAve(pts[0].fY, pts[1].fY));
187 return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
188 data.fPos, data.fCount, tm);
189 }
190
MakeSweep(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm)191 static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
192 SkPoint center;
193 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
194 SkScalarAve(pts[0].fY, pts[1].fY));
195 return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
196 }
197
Make2Conical(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm)198 static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
199 SkPoint center0, center1;
200 center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
201 SkScalarAve(pts[0].fY, pts[1].fY));
202 center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
203 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
204 return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
205 center0, (pts[1].fX - pts[0].fX) / 2,
206 data.fColors, data.fPos, data.fCount, tm);
207 }
208
209 typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkShader::TileMode);
210 static const GradMaker gGradMakers[] = {
211 MakeLinear, MakeRadial, MakeSweep, Make2Conical
212 };
213
gradient_slide(SkCanvas * canvas)214 static void gradient_slide(SkCanvas* canvas) {
215 SkPoint pts[2] = {
216 { 0, 0 },
217 { SkIntToScalar(100), SkIntToScalar(100) }
218 };
219 SkShader::TileMode tm = SkShader::kClamp_TileMode;
220 SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
221 SkPaint paint;
222 paint.setAntiAlias(true);
223 paint.setDither(true);
224
225 canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
226 for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
227 canvas->save();
228 for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
229 paint.setShader(gGradMakers[j](pts, gGradData[i], tm));
230 canvas->drawRect(r, paint);
231 canvas->translate(0, SkIntToScalar(120));
232 }
233 canvas->restore();
234 canvas->translate(SkIntToScalar(120), 0);
235 }
236 }
237
238 ///////////////////////////////////////////////////////////////////////////////
239
240 #include "SkPathMeasure.h"
241
getpathlen(const SkPath & path)242 static SkScalar getpathlen(const SkPath& path) {
243 SkPathMeasure meas(path, false);
244 return meas.getLength();
245 }
246
textonpath_slide(SkCanvas * canvas)247 static void textonpath_slide(SkCanvas* canvas) {
248 const char* text = "Displacement";
249 size_t len =strlen(text);
250 SkPath path;
251 path.moveTo(100, 300);
252 path.quadTo(300, 100, 500, 300);
253 path.offset(0, -100);
254
255 SkPaint paint;
256 paint.setAntiAlias(true);
257 paint.setTextSize(40);
258
259 paint.setStyle(SkPaint::kStroke_Style);
260 canvas->drawPath(path, paint);
261 paint.setStyle(SkPaint::kFill_Style);
262
263 SkScalar x = 50;
264 paint.setColor(0xFF008800);
265 canvas->drawTextOnPathHV(text, len, path,
266 x, paint.getTextSize()*2/3, paint);
267 paint.setColor(SK_ColorRED);
268 canvas->drawTextOnPathHV(text, len, path,
269 x + 60, 0, paint);
270 paint.setColor(SK_ColorBLUE);
271 canvas->drawTextOnPathHV(text, len, path,
272 x + 120, -paint.getTextSize()*2/3, paint);
273
274 path.offset(0, 200);
275 paint.setTextAlign(SkPaint::kRight_Align);
276
277 text = "Matrices";
278 len = strlen(text);
279 SkScalar pathLen = getpathlen(path);
280 SkMatrix matrix;
281
282 paint.setColor(SK_ColorBLACK);
283 paint.setStyle(SkPaint::kStroke_Style);
284 canvas->drawPath(path, paint);
285 paint.setStyle(SkPaint::kFill_Style);
286
287 paint.setTextSize(50);
288 canvas->drawTextOnPath(text, len, path, nullptr, paint);
289
290 paint.setColor(SK_ColorRED);
291 matrix.setScale(-SK_Scalar1, SK_Scalar1);
292 matrix.postTranslate(pathLen, 0);
293 canvas->drawTextOnPath(text, len, path, &matrix, paint);
294
295 paint.setColor(SK_ColorBLUE);
296 matrix.setScale(SK_Scalar1, -SK_Scalar1);
297 canvas->drawTextOnPath(text, len, path, &matrix, paint);
298
299 paint.setColor(0xFF008800);
300 matrix.setScale(-SK_Scalar1, -SK_Scalar1);
301 matrix.postTranslate(pathLen, 0);
302 canvas->drawTextOnPath(text, len, path, &matrix, paint);
303 }
304
305 ///////////////////////////////////////////////////////////////////////////////
306
307 #include "DecodeFile.h"
308 #include "SkOSFile.h"
309 #include "SkRandom.h"
310 #include "SkStream.h"
311
make_shader0(SkIPoint * size)312 static sk_sp<SkShader> make_shader0(SkIPoint* size) {
313 SkBitmap bm;
314
315 decode_file("/skimages/logo.gif", &bm);
316 size->set(bm.width(), bm.height());
317 return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
318 SkShader::kClamp_TileMode);
319 }
320
make_shader1(const SkIPoint & size)321 static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
322 SkPoint pts[] = { { 0, 0 },
323 { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
324 SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
325 return SkGradientShader::MakeLinear(pts, colors, nullptr,
326 SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
327 }
328
329 class Rec {
330 public:
331 SkCanvas::VertexMode fMode;
332 int fCount;
333 SkPoint* fVerts;
334 SkPoint* fTexs;
335
Rec()336 Rec() : fCount(0), fVerts(nullptr), fTexs(nullptr) {}
~Rec()337 ~Rec() { delete[] fVerts; delete[] fTexs; }
338 };
339
make_tris(Rec * rec)340 static void make_tris(Rec* rec) {
341 int n = 10;
342 SkRandom rand;
343
344 rec->fMode = SkCanvas::kTriangles_VertexMode;
345 rec->fCount = n * 3;
346 rec->fVerts = new SkPoint[rec->fCount];
347
348 for (int i = 0; i < n; i++) {
349 SkPoint* v = &rec->fVerts[i*3];
350 for (int j = 0; j < 3; j++) {
351 v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
352 }
353 }
354 }
355
make_fan(Rec * rec,int texWidth,int texHeight)356 static void make_fan(Rec* rec, int texWidth, int texHeight) {
357 const SkScalar tx = SkIntToScalar(texWidth);
358 const SkScalar ty = SkIntToScalar(texHeight);
359 const int n = 24;
360
361 rec->fMode = SkCanvas::kTriangleFan_VertexMode;
362 rec->fCount = n + 2;
363 rec->fVerts = new SkPoint[rec->fCount];
364 rec->fTexs = new SkPoint[rec->fCount];
365
366 SkPoint* v = rec->fVerts;
367 SkPoint* t = rec->fTexs;
368
369 v[0].set(0, 0);
370 t[0].set(0, 0);
371 for (int i = 0; i < n; i++) {
372 SkScalar cos;
373 SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
374 v[i+1].set(cos, sin);
375 t[i+1].set(i*tx/n, ty);
376 }
377 v[n+1] = v[1];
378 t[n+1].set(tx, ty);
379
380 SkMatrix m;
381 m.setScale(SkIntToScalar(100), SkIntToScalar(100));
382 m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
383 m.mapPoints(v, rec->fCount);
384 }
385
make_strip(Rec * rec,int texWidth,int texHeight)386 static void make_strip(Rec* rec, int texWidth, int texHeight) {
387 const SkScalar tx = SkIntToScalar(texWidth);
388 const SkScalar ty = SkIntToScalar(texHeight);
389 const int n = 24;
390
391 rec->fMode = SkCanvas::kTriangleStrip_VertexMode;
392 rec->fCount = 2 * (n + 1);
393 rec->fVerts = new SkPoint[rec->fCount];
394 rec->fTexs = new SkPoint[rec->fCount];
395
396 SkPoint* v = rec->fVerts;
397 SkPoint* t = rec->fTexs;
398
399 for (int i = 0; i < n; i++) {
400 SkScalar cos;
401 SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
402 v[i*2 + 0].set(cos/2, sin/2);
403 v[i*2 + 1].set(cos, sin);
404
405 t[i*2 + 0].set(tx * i / n, ty);
406 t[i*2 + 1].set(tx * i / n, 0);
407 }
408 v[2*n + 0] = v[0];
409 v[2*n + 1] = v[1];
410
411 t[2*n + 0].set(tx, ty);
412 t[2*n + 1].set(tx, 0);
413
414 SkMatrix m;
415 m.setScale(SkIntToScalar(100), SkIntToScalar(100));
416 m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
417 m.mapPoints(v, rec->fCount);
418 }
419
mesh_slide(SkCanvas * canvas)420 static void mesh_slide(SkCanvas* canvas) {
421 Rec fRecs[3];
422 SkIPoint size;
423
424 auto fShader0 = make_shader0(&size);
425 auto fShader1 = make_shader1(size);
426
427 make_strip(&fRecs[0], size.fX, size.fY);
428 make_fan(&fRecs[1], size.fX, size.fY);
429 make_tris(&fRecs[2]);
430
431 SkPaint paint;
432 paint.setDither(true);
433 paint.setFilterQuality(kLow_SkFilterQuality);
434
435 for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
436 canvas->save();
437
438 paint.setShader(nullptr);
439 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
440 fRecs[i].fVerts, fRecs[i].fTexs,
441 nullptr, nullptr, 0, paint);
442
443 canvas->translate(SkIntToScalar(210), 0);
444
445 paint.setShader(fShader0);
446 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
447 fRecs[i].fVerts, fRecs[i].fTexs,
448 nullptr, nullptr, 0, paint);
449
450 canvas->translate(SkIntToScalar(210), 0);
451
452 paint.setShader(fShader1);
453 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
454 fRecs[i].fVerts, fRecs[i].fTexs,
455 nullptr, nullptr, 0, paint);
456 canvas->restore();
457
458 canvas->translate(0, SkIntToScalar(250));
459 }
460 }
461
462 ///////////////////////////////////////////////////////////////////////////////
463
r0(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)464 static void r0(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
465 {
466 p.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
467 SkBlurMask::ConvertRadiusToSigma(3)));
468 rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
469
470 p.setMaskFilter(nullptr);
471 p.setStyle(SkPaint::kStroke_Style);
472 p.setStrokeWidth(SK_Scalar1);
473 rastBuilder->addLayer(p);
474
475 p.setAlpha(0x11);
476 p.setStyle(SkPaint::kFill_Style);
477 p.setBlendMode(SkBlendMode::kSrc);
478 rastBuilder->addLayer(p);
479 }
480
r1(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)481 static void r1(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
482 {
483 rastBuilder->addLayer(p);
484
485 p.setAlpha(0x40);
486 p.setBlendMode(SkBlendMode::kSrc);
487 p.setStyle(SkPaint::kStroke_Style);
488 p.setStrokeWidth(SK_Scalar1*2);
489 rastBuilder->addLayer(p);
490 }
491
r2(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)492 static void r2(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
493 {
494 p.setStyle(SkPaint::kStrokeAndFill_Style);
495 p.setStrokeWidth(SK_Scalar1*4);
496 rastBuilder->addLayer(p);
497
498 p.setStyle(SkPaint::kStroke_Style);
499 p.setStrokeWidth(SK_Scalar1*3/2);
500 p.setBlendMode(SkBlendMode::kClear);
501 rastBuilder->addLayer(p);
502 }
503
r3(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)504 static void r3(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
505 {
506 p.setStyle(SkPaint::kStroke_Style);
507 p.setStrokeWidth(SK_Scalar1*3);
508 rastBuilder->addLayer(p);
509
510 p.setAlpha(0x20);
511 p.setStyle(SkPaint::kFill_Style);
512 p.setBlendMode(SkBlendMode::kSrc);
513 rastBuilder->addLayer(p);
514 }
515
r4(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)516 static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
517 {
518 p.setAlpha(0x60);
519 rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
520
521 p.setAlpha(0xFF);
522 p.setBlendMode(SkBlendMode::kClear);
523 rastBuilder->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
524
525 p.setBlendMode(SkBlendMode::kSrcOver);
526 rastBuilder->addLayer(p);
527 }
528
529 #include "SkDiscretePathEffect.h"
530
r5(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)531 static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
532 {
533 rastBuilder->addLayer(p);
534
535 p.setPathEffect(SkDiscretePathEffect::Make(SK_Scalar1*4, SK_Scalar1*3));
536 p.setBlendMode(SkBlendMode::kSrcOut);
537 rastBuilder->addLayer(p);
538 }
539
r6(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)540 static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
541 {
542 rastBuilder->addLayer(p);
543
544 p.setAntiAlias(false);
545 SkLayerRasterizer::Builder rastBuilder2;
546 r5(&rastBuilder2, p);
547 p.setRasterizer(rastBuilder2.detach());
548 p.setBlendMode(SkBlendMode::kClear);
549 rastBuilder->addLayer(p);
550 }
551
552 #include "Sk2DPathEffect.h"
553
MakeDotEffect(SkScalar radius,const SkMatrix & matrix)554 static sk_sp<SkPathEffect> MakeDotEffect(SkScalar radius, const SkMatrix& matrix) {
555 SkPath path;
556 path.addCircle(0, 0, radius);
557 return SkPath2DPathEffect::Make(matrix, path);
558 }
559
r7(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)560 static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
561 {
562 SkMatrix lattice;
563 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
564 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
565 p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice));
566 rastBuilder->addLayer(p);
567 }
568
r8(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)569 static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
570 {
571 rastBuilder->addLayer(p);
572
573 SkMatrix lattice;
574 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
575 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
576 p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice));
577 p.setBlendMode(SkBlendMode::kClear);
578 rastBuilder->addLayer(p);
579
580 p.setPathEffect(nullptr);
581 p.setBlendMode(SkBlendMode::kSrcOver);
582 p.setStyle(SkPaint::kStroke_Style);
583 p.setStrokeWidth(SK_Scalar1);
584 rastBuilder->addLayer(p);
585 }
586
r9(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)587 static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
588 {
589 rastBuilder->addLayer(p);
590
591 SkMatrix lattice;
592 lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
593 lattice.postRotate(SkIntToScalar(30), 0, 0);
594 p.setPathEffect(SkLine2DPathEffect::Make(SK_Scalar1*2, lattice));
595 p.setBlendMode(SkBlendMode::kClear);
596 rastBuilder->addLayer(p);
597
598 p.setPathEffect(nullptr);
599 p.setBlendMode(SkBlendMode::kSrcOver);
600 p.setStyle(SkPaint::kStroke_Style);
601 p.setStrokeWidth(SK_Scalar1);
602 rastBuilder->addLayer(p);
603 }
604
605 typedef void (*raster_proc)(SkLayerRasterizer::Builder*, SkPaint&);
606
607 static const raster_proc gRastProcs[] = {
608 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
609 };
610
apply_shader(SkPaint * paint,int index)611 static void apply_shader(SkPaint* paint, int index) {
612 raster_proc proc = gRastProcs[index];
613 SkPaint p;
614 SkLayerRasterizer::Builder rastBuilder;
615
616 p.setAntiAlias(true);
617 proc(&rastBuilder, p);
618 paint->setRasterizer(rastBuilder.detach());
619 paint->setColor(SK_ColorBLUE);
620 }
621
622 #include "SkTypeface.h"
623
texteffect_slide(SkCanvas * canvas)624 static void texteffect_slide(SkCanvas* canvas) {
625 const char* str = "Google";
626 size_t len = strlen(str);
627 SkScalar x = 20;
628 SkScalar y = 80;
629 SkPaint paint;
630 paint.setTypeface(SkTypeface::MakeFromName("Georgia",
631 SkFontStyle::FromOldStyle(SkTypeface::kItalic)));
632 paint.setTextSize(75);
633 paint.setAntiAlias(true);
634 paint.setColor(SK_ColorBLUE);
635 for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
636 apply_shader(&paint, (int)i);
637 canvas->drawText(str, len, x, y, paint);
638 y += 80;
639 if (i == 4) {
640 x += 320;
641 y = 80;
642 }
643 }
644 }
645
646 ///////////////////////////////////////////////////////////////////////////////
647
648 #include "SkImageEncoder.h"
649
650 static const SlideProc gProc[] = {
651 patheffect_slide,
652 gradient_slide,
653 textonpath_slide,
654 mesh_slide,
655 texteffect_slide
656 };
657
658 class SlideView : public SampleView {
659 int fIndex;
660 bool fOnce;
661 public:
SlideView()662 SlideView() {
663 fOnce = false;
664 }
665
init()666 void init() {
667 if (fOnce) {
668 return;
669 }
670 fOnce = true;
671
672 fIndex = 0;
673
674 SkBitmap bm;
675 bm.allocN32Pixels(1024, 768);
676 SkCanvas canvas(bm);
677 SkScalar s = SkIntToScalar(1024) / 640;
678 canvas.scale(s, s);
679 for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); i++) {
680 canvas.save();
681 canvas.drawColor(BG_COLOR);
682 gProc[i](&canvas);
683 canvas.restore();
684 SkString str;
685 str.printf("/skimages/slide_" SK_SIZE_T_SPECIFIER ".png", i);
686 sk_tool_utils::EncodeImageToFile(str.c_str(), bm, SkEncodedImageFormat::kPNG, 100);
687 }
688 this->setBGColor(BG_COLOR);
689 }
690
691 protected:
692 // overrides from SkEventSink
onQuery(SkEvent * evt)693 bool onQuery(SkEvent* evt) override {
694 if (SampleCode::TitleQ(*evt)) {
695 SampleCode::TitleR(evt, "Slides");
696 return true;
697 }
698 return this->INHERITED::onQuery(evt);
699 }
700
onDrawContent(SkCanvas * canvas)701 void onDrawContent(SkCanvas* canvas) override {
702 this->init();
703 gProc[fIndex](canvas);
704 }
705
onFindClickHandler(SkScalar x,SkScalar y,unsigned)706 SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
707 this->init();
708 fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
709 this->inval(nullptr);
710 return nullptr;
711 }
712
713 private:
714 typedef SampleView INHERITED;
715 };
716
717 //////////////////////////////////////////////////////////////////////////////
718
MyFactory()719 static SkView* MyFactory() { return new SlideView; }
720 static SkViewRegister reg(MyFactory);
721
