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
8 #include "gm.h"
9 #include "SkBlurMask.h"
10 #include "SkBlurMaskFilter.h"
11 #include "SkReadBuffer.h"
12 #include "SkWriteBuffer.h"
13 #include "SkLayerRasterizer.h"
14
r0(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)15 static void r0(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
16 p.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
17 SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3))))->unref();
18 rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
19
20 p.setMaskFilter(nullptr);
21 p.setStyle(SkPaint::kStroke_Style);
22 p.setStrokeWidth(SK_Scalar1);
23 rastBuilder->addLayer(p);
24
25 p.setAlpha(0x11);
26 p.setStyle(SkPaint::kFill_Style);
27 p.setXfermodeMode(SkXfermode::kSrc_Mode);
28 rastBuilder->addLayer(p);
29 }
30
r1(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)31 static void r1(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
32 rastBuilder->addLayer(p);
33
34 p.setAlpha(0x40);
35 p.setXfermodeMode(SkXfermode::kSrc_Mode);
36 p.setStyle(SkPaint::kStroke_Style);
37 p.setStrokeWidth(SK_Scalar1*2);
38 rastBuilder->addLayer(p);
39 }
40
r2(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)41 static void r2(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
42 p.setStyle(SkPaint::kStrokeAndFill_Style);
43 p.setStrokeWidth(SK_Scalar1*4);
44 rastBuilder->addLayer(p);
45
46 p.setStyle(SkPaint::kStroke_Style);
47 p.setStrokeWidth(SK_Scalar1*3/2);
48 p.setXfermodeMode(SkXfermode::kClear_Mode);
49 rastBuilder->addLayer(p);
50 }
51
r3(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)52 static void r3(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
53 p.setStyle(SkPaint::kStroke_Style);
54 p.setStrokeWidth(SK_Scalar1*3);
55 rastBuilder->addLayer(p);
56
57 p.setAlpha(0x20);
58 p.setStyle(SkPaint::kFill_Style);
59 p.setXfermodeMode(SkXfermode::kSrc_Mode);
60 rastBuilder->addLayer(p);
61 }
62
r4(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)63 static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
64 p.setAlpha(0x60);
65 rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
66
67 p.setAlpha(0xFF);
68 p.setXfermodeMode(SkXfermode::kClear_Mode);
69 rastBuilder->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
70
71 p.setXfermode(nullptr);
72 rastBuilder->addLayer(p);
73 }
74
75 #include "SkDiscretePathEffect.h"
76
r5(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)77 static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
78 rastBuilder->addLayer(p);
79
80 p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref();
81 p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
82 rastBuilder->addLayer(p);
83 }
84
r6(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)85 static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
86 rastBuilder->addLayer(p);
87
88 p.setAntiAlias(false);
89 SkLayerRasterizer::Builder rastBuilder2;
90 r5(&rastBuilder2, p);
91 p.setRasterizer(rastBuilder2.detachRasterizer())->unref();
92 p.setXfermodeMode(SkXfermode::kClear_Mode);
93 rastBuilder->addLayer(p);
94 }
95
96 #include "Sk2DPathEffect.h"
97
MakeDotEffect(SkScalar radius,const SkMatrix & matrix)98 static SkPathEffect* MakeDotEffect(SkScalar radius, const SkMatrix& matrix) {
99 SkPath path;
100 path.addCircle(0, 0, radius);
101 return SkPath2DPathEffect::Create(matrix, path);
102 }
103
r7(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)104 static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
105 SkMatrix lattice;
106 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
107 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
108 p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice))->unref();
109 rastBuilder->addLayer(p);
110 }
111
r8(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)112 static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
113 rastBuilder->addLayer(p);
114
115 SkMatrix lattice;
116 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
117 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
118 p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice))->unref();
119 p.setXfermodeMode(SkXfermode::kClear_Mode);
120 rastBuilder->addLayer(p);
121
122 p.setPathEffect(nullptr);
123 p.setXfermode(nullptr);
124 p.setStyle(SkPaint::kStroke_Style);
125 p.setStrokeWidth(SK_Scalar1);
126 rastBuilder->addLayer(p);
127 }
128
r9(SkLayerRasterizer::Builder * rastBuilder,SkPaint & p)129 static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
130 rastBuilder->addLayer(p);
131
132 SkMatrix lattice;
133 lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
134 lattice.postRotate(SkIntToScalar(30), 0, 0);
135 p.setPathEffect(SkLine2DPathEffect::Create(SK_Scalar1*2, lattice))->unref();
136 p.setXfermodeMode(SkXfermode::kClear_Mode);
137 rastBuilder->addLayer(p);
138
139 p.setPathEffect(nullptr);
140 p.setXfermode(nullptr);
141 p.setStyle(SkPaint::kStroke_Style);
142 p.setStrokeWidth(SK_Scalar1);
143 rastBuilder->addLayer(p);
144 }
145
146 typedef void (*raster_proc)(SkLayerRasterizer::Builder*, SkPaint&);
147
148 static const raster_proc gRastProcs[] = {
149 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
150 };
151
152 #include "SkXfermode.h"
153
apply_shader(SkPaint * paint,int index)154 static void apply_shader(SkPaint* paint, int index) {
155 raster_proc proc = gRastProcs[index];
156 if (proc)
157 {
158 SkPaint p;
159 SkLayerRasterizer::Builder rastBuilder;
160
161 p.setAntiAlias(true);
162 proc(&rastBuilder, p);
163 paint->setRasterizer(rastBuilder.detachRasterizer())->unref();
164 }
165
166 #if 0
167 SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 };
168 paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref();
169 #endif
170 paint->setColor(SK_ColorBLUE);
171 }
172
173 DEF_SIMPLE_GM(texteffects, canvas, 460, 680) {
174 canvas->save();
175
176 SkPaint paint;
177 paint.setAntiAlias(true);
178 sk_tool_utils::set_portable_typeface(&paint);
179 paint.setTextSize(SkIntToScalar(56));
180
181 SkScalar x = SkIntToScalar(20);
182 SkScalar y = paint.getTextSize();
183
184 SkString str("Hamburgefons");
185
186 for (int i = 0; i < static_cast<int>(SK_ARRAY_COUNT(gRastProcs)); i++) {
187 apply_shader(&paint, i);
188
189 // paint.setMaskFilter(nullptr);
190 // paint.setColor(SK_ColorBLACK);
191
192 canvas->drawText(str.c_str(), str.size(), x, y, paint);
193
194 y += paint.getFontSpacing();
195 }
196
197 canvas->restore();
198 }
199
200 DEF_SIMPLE_GM(textunderstrike, canvas, 460, 680) {
201 canvas->clear(SK_ColorYELLOW);
202 SkPaint paint;
203 sk_tool_utils::set_portable_typeface(&paint);
204 paint.setTextSize(50);
205 paint.setStrokeWidth(5);
206 paint.setAntiAlias(true);
207
__anond39ee1220102() 208 auto drawText = [&]() {
209 paint.setStyle(SkPaint::kFill_Style);
210 canvas->drawText("Hello", 5, 100, 50, paint);
211 paint.setStyle(SkPaint::kStroke_Style);
212 canvas->drawText("Hello", 5, 100, 100, paint);
213 canvas->translate(0, 100);
214 };
215
216 drawText();
217 paint.setUnderlineText(true);
218 drawText();
219 paint.setUnderlineText(false);
220 paint.setStrikeThruText(true);
221 drawText();
222 paint.setUnderlineText(true);
223 drawText();
224 paint.setColor(SK_ColorWHITE);
225 paint.setStyle(SkPaint::kStroke_Style);
226 canvas->drawText("Hello", 5, 100, 50, paint);
227 paint.setColor(SK_ColorBLUE);
228 paint.setStyle(SkPaint::kFill_Style);
229 canvas->drawText("Hello", 5, 100, 50, paint);
230 }
231
create_underline(const SkTDArray<SkScalar> & intersections,SkScalar last,SkScalar finalPos,SkScalar uPos,SkScalar uWidth,SkScalar textSize)232 static SkPath create_underline(const SkTDArray<SkScalar>& intersections,
233 SkScalar last, SkScalar finalPos,
234 SkScalar uPos, SkScalar uWidth, SkScalar textSize) {
235 SkPath underline;
236 SkScalar end = last;
237 for (int index = 0; index < intersections.count(); index += 2) {
238 SkScalar start = intersections[index] - uWidth;;
239 end = intersections[index + 1] + uWidth;
240 if (start > last && last + textSize / 12 < start) {
241 underline.moveTo(last, uPos);
242 underline.lineTo(start, uPos);
243 }
244 last = end;
245 }
246 if (end < finalPos) {
247 underline.moveTo(end, uPos);
248 underline.lineTo(finalPos, uPos);
249 }
250 return underline;
251 }
252
find_intercepts(const char * test,size_t len,SkScalar x,SkScalar y,const SkPaint & paint,SkScalar uWidth,SkTDArray<SkScalar> * intersections)253 static void find_intercepts(const char* test, size_t len, SkScalar x, SkScalar y,
254 const SkPaint& paint, SkScalar uWidth, SkTDArray<SkScalar>* intersections) {
255 SkScalar uPos = y + uWidth;
256 SkScalar bounds[2] = { uPos - uWidth / 2, uPos + uWidth / 2 };
257 int count = paint.getTextIntercepts(test, len, x, y, bounds, nullptr);
258 SkASSERT(!(count % 2));
259 if (count) {
260 intersections->setCount(count);
261 paint.getTextIntercepts(test, len, x, y, bounds, intersections->begin());
262 }
263 }
264
265 DEF_SIMPLE_GM(fancyunderline, canvas, 900, 1350) {
266 SkPaint paint;
267 paint.setAntiAlias(true);
268 const char* fam[] = { "sans-serif", "serif", "monospace" };
269 const char test[] = "aAjJgGyY_|{-(~[,]qQ}pP}zZ";
270 SkPoint textPt = { 10, 80 };
271 for (int font = 0; font < 3; ++font) {
272 sk_tool_utils::set_portable_typeface(&paint, fam[font], SkTypeface::kNormal);
273 for (SkScalar textSize = 100; textSize > 10; textSize -= 20) {
274 paint.setTextSize(textSize);
275 const SkScalar uWidth = textSize / 15;
276 paint.setStrokeWidth(uWidth);
277 paint.setStyle(SkPaint::kFill_Style);
278 canvas->drawText(test, sizeof(test) - 1, textPt.fX, textPt.fY, paint);
279
280 SkTDArray<SkScalar> intersections;
281 find_intercepts(test, sizeof(test) - 1, textPt.fX, textPt.fY, paint, uWidth,
282 &intersections);
283
284 SkScalar start = textPt.fX;
285 SkScalar end = paint.measureText(test, sizeof(test) - 1) + textPt.fX;
286 SkScalar uPos = textPt.fY + uWidth;
287 SkPath underline = create_underline(intersections, start, end, uPos, uWidth, textSize);
288 paint.setStyle(SkPaint::kStroke_Style);
289 canvas->drawPath(underline, paint);
290
291 canvas->translate(0, textSize * 1.3f);
292 }
293 canvas->translate(0, 60);
294 }
295 }
296
find_intercepts(const char * test,size_t len,const SkPoint * pos,const SkPaint & paint,SkScalar uWidth,SkTDArray<SkScalar> * intersections)297 static void find_intercepts(const char* test, size_t len, const SkPoint* pos, const SkPaint& paint,
298 SkScalar uWidth, SkTDArray<SkScalar>* intersections) {
299 SkScalar uPos = pos[0].fY + uWidth;
300 SkScalar bounds[2] = { uPos - uWidth / 2, uPos + uWidth / 2 };
301 int count = paint.getPosTextIntercepts(test, len, pos, bounds, nullptr);
302 SkASSERT(!(count % 2));
303 if (count) {
304 intersections->setCount(count);
305 paint.getPosTextIntercepts(test, len, pos, bounds, intersections->begin());
306 }
307 }
308
309 DEF_SIMPLE_GM(fancyposunderline, canvas, 900, 1350) {
310 SkPaint paint;
311 paint.setAntiAlias(true);
312 const char* fam[] = { "sans-serif", "serif", "monospace" };
313 const char test[] = "aAjJgGyY_|{-(~[,]qQ}pP}zZ";
314 SkPoint textPt = { 10, 80 };
315 for (int font = 0; font < 3; ++font) {
316 sk_tool_utils::set_portable_typeface(&paint, fam[font], SkTypeface::kNormal);
317 for (SkScalar textSize = 100; textSize > 10; textSize -= 20) {
318 paint.setTextSize(textSize);
319 const SkScalar uWidth = textSize / 15;
320 paint.setStrokeWidth(uWidth);
321 paint.setStyle(SkPaint::kFill_Style);
322 int widthCount = paint.getTextWidths(test, sizeof(test) - 1, nullptr);
323 SkTDArray<SkScalar> widths;
324 widths.setCount(widthCount);
325 (void) paint.getTextWidths(test, sizeof(test) - 1, widths.begin());
326 SkTDArray<SkPoint> pos;
327 pos.setCount(widthCount);
328 SkScalar posX = textPt.fX;
329 for (int index = 0; index < widthCount; ++index) {
330 pos[index].fX = posX;
331 posX += widths[index];
332 pos[index].fY = textPt.fY + (textSize / 25) * (index % 4);
333 }
334 canvas->drawPosText(test, sizeof(test) - 1, pos.begin(), paint);
335
336 SkTDArray<SkScalar> intersections;
337 find_intercepts(test, sizeof(test) - 1, pos.begin(), paint, uWidth, &intersections);
338
339 SkScalar start = textPt.fX;
340 SkScalar end = posX;
341 SkScalar uPos = textPt.fY + uWidth;
342 SkPath underline = create_underline(intersections, start, end, uPos, uWidth, textSize);
343 paint.setStyle(SkPaint::kStroke_Style);
344 canvas->drawPath(underline, paint);
345
346 canvas->translate(0, textSize * 1.3f);
347 }
348 canvas->translate(0, 60);
349 }
350 }
351
352 DEF_SIMPLE_GM(fancyunderlinebars, canvas, 1500, 460) {
353 SkPaint paint;
354 paint.setAntiAlias(true);
355 const char test[] = " .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_ .}]_";
356 SkPoint textPt = { 10, 80 };
357 sk_tool_utils::set_portable_typeface(&paint, "serif");
358 for (SkScalar textSize = 100; textSize > 10; textSize -= 20) {
359 paint.setTextSize(textSize);
360 SkScalar uWidth = textSize / 15;
361 paint.setStrokeWidth(uWidth);
362 paint.setStyle(SkPaint::kFill_Style);
363 int widthCount = paint.getTextWidths(test, sizeof(test) - 1, nullptr);
364 SkTDArray<SkScalar> widths;
365 widths.setCount(widthCount);
366 (void) paint.getTextWidths(test, sizeof(test) - 1, widths.begin());
367 SkTDArray<SkPoint> pos;
368 pos.setCount(widthCount);
369 SkScalar posX = textPt.fX;
370 pos[0] = textPt;
371 posX += widths[0];
372 for (int index = 1; index < widthCount; ++index) {
373 pos[index].fX = posX;
374 posX += widths[index];
375 pos[index].fY = textPt.fY - (textSize / 50) * (index / 5) + textSize / 50 * 4;
376 }
377 canvas->drawPosText(test, sizeof(test) - 1, pos.begin(), paint);
378
379 SkTDArray<SkScalar> intersections;
380 find_intercepts(test, sizeof(test) - 1, pos.begin(), paint, uWidth, &intersections);
381
382 SkScalar start = textPt.fX;
383 SkScalar end = posX;
384 SkScalar uPos = pos[0].fY + uWidth;
385 SkPath underline = create_underline(intersections, start, end, uPos, uWidth, textSize);
386 paint.setStyle(SkPaint::kStroke_Style);
387 canvas->drawPath(underline, paint);
388 canvas->translate(0, textSize * 1.3f);
389 }
390 }
391