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 "include/core/SkCanvas.h"
9 #include "include/core/SkColorPriv.h"
10 #include "include/core/SkFont.h"
11 #include "include/core/SkPaint.h"
12 #include "include/core/SkPath.h"
13 #include "include/utils/SkRandom.h"
14 #include "samplecode/Sample.h"
15 #include "src/core/SkClipOpPriv.h"
16 #include "src/core/SkPathPriv.h"
17 #include "tools/Resources.h"
18
19 constexpr int W = 150;
20 constexpr int H = 200;
21
show_text(SkCanvas * canvas,bool doAA)22 static void show_text(SkCanvas* canvas, bool doAA) {
23 SkRandom rand;
24 SkPaint paint;
25 SkFont font(nullptr, 20);
26 font.setEdging(doAA ? SkFont::Edging::kSubpixelAntiAlias : SkFont::Edging::kAlias);
27
28 for (int i = 0; i < 200; ++i) {
29 paint.setColor((SK_A32_MASK << SK_A32_SHIFT) | rand.nextU());
30 canvas->drawString("Hamburgefons", rand.nextSScalar1() * W, rand.nextSScalar1() * H + 20,
31 font, paint);
32 }
33 }
34
show_fill(SkCanvas * canvas,bool doAA)35 static void show_fill(SkCanvas* canvas, bool doAA) {
36 SkRandom rand;
37 SkPaint paint;
38 paint.setAntiAlias(doAA);
39
40 for (int i = 0; i < 50; ++i) {
41 SkRect r;
42 SkPath p;
43
44 r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
45 rand.nextUScalar1() * W, rand.nextUScalar1() * H);
46 paint.setColor(rand.nextU());
47 canvas->drawRect(r, paint);
48
49 r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
50 rand.nextUScalar1() * W, rand.nextUScalar1() * H);
51 paint.setColor(rand.nextU());
52 p.addOval(r);
53 canvas->drawPath(p, paint);
54 }
55 }
56
randRange(SkRandom & rand,SkScalar min,SkScalar max)57 static SkScalar randRange(SkRandom& rand, SkScalar min, SkScalar max) {
58 SkASSERT(min <= max);
59 return min + rand.nextUScalar1() * (max - min);
60 }
61
show_stroke(SkCanvas * canvas,bool doAA,SkScalar strokeWidth,int n)62 static void show_stroke(SkCanvas* canvas, bool doAA, SkScalar strokeWidth, int n) {
63 SkRandom rand;
64 SkPaint paint;
65 paint.setAntiAlias(doAA);
66 paint.setStyle(SkPaint::kStroke_Style);
67 paint.setStrokeWidth(strokeWidth);
68
69 for (int i = 0; i < n; ++i) {
70 SkRect r;
71 SkPath p;
72
73 r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
74 rand.nextUScalar1() * W, rand.nextUScalar1() * H);
75 paint.setColor(rand.nextU());
76 canvas->drawRect(r, paint);
77
78 r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
79 rand.nextUScalar1() * W, rand.nextUScalar1() * H);
80 paint.setColor(rand.nextU());
81 p.addOval(r);
82 canvas->drawPath(p, paint);
83
84 const SkScalar minx = -SkIntToScalar(W)/4;
85 const SkScalar maxx = 5*SkIntToScalar(W)/4;
86 const SkScalar miny = -SkIntToScalar(H)/4;
87 const SkScalar maxy = 5*SkIntToScalar(H)/4;
88 paint.setColor(rand.nextU());
89 canvas->drawLine(randRange(rand, minx, maxx), randRange(rand, miny, maxy),
90 randRange(rand, minx, maxx), randRange(rand, miny, maxy),
91 paint);
92 }
93 }
94
show_hair(SkCanvas * canvas,bool doAA)95 static void show_hair(SkCanvas* canvas, bool doAA) {
96 show_stroke(canvas, doAA, 0, 150);
97 }
98
show_thick(SkCanvas * canvas,bool doAA)99 static void show_thick(SkCanvas* canvas, bool doAA) {
100 show_stroke(canvas, doAA, SkIntToScalar(5), 50);
101 }
102
103 typedef void (*CanvasProc)(SkCanvas*, bool);
104
105 class ClipView : public Sample {
name()106 SkString name() override { return SkString("Clip"); }
107
onDrawContent(SkCanvas * canvas)108 void onDrawContent(SkCanvas* canvas) override {
109 canvas->drawColor(SK_ColorWHITE);
110 canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
111
112 static const CanvasProc gProc[] = {
113 show_text, show_thick, show_hair, show_fill
114 };
115
116 SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
117 SkPath clipPath;
118 r.inset(SK_Scalar1 / 4, SK_Scalar1 / 4);
119 clipPath.addRoundRect(r, SkIntToScalar(20), SkIntToScalar(20));
120
121 // clipPath.toggleInverseFillType();
122
123 for (int aa = 0; aa <= 1; ++aa) {
124 canvas->save();
125 for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); ++i) {
126 canvas->save();
127 canvas->clipPath(clipPath, kIntersect_SkClipOp, SkToBool(aa));
128 // canvas->drawColor(SK_ColorWHITE);
129 gProc[i](canvas, SkToBool(aa));
130 canvas->restore();
131 canvas->translate(W * SK_Scalar1 * 8 / 7, 0);
132 }
133 canvas->restore();
134 canvas->translate(0, H * SK_Scalar1 * 8 / 7);
135 }
136 }
137 };
138
139 DEF_SAMPLE( return new ClipView(); )
140
141 ///////////////////////////////////////////////////////////////////////////////
142
143 struct SkHalfPlane {
144 SkScalar fA, fB, fC;
145
evalSkHalfPlane146 SkScalar eval(SkScalar x, SkScalar y) const {
147 return fA * x + fB * y + fC;
148 }
operator ()SkHalfPlane149 SkScalar operator()(SkScalar x, SkScalar y) const { return this->eval(x, y); }
150
twoPtsSkHalfPlane151 bool twoPts(SkPoint pts[2]) const {
152 // normalize plane to help with the perpendicular step, below
153 SkScalar len = SkScalarSqrt(fA*fA + fB*fB);
154 if (!len) {
155 return false;
156 }
157 SkScalar denom = SkScalarInvert(len);
158 SkScalar a = fA * denom;
159 SkScalar b = fB * denom;
160 SkScalar c = fC * denom;
161
162 // We compute p0 on the half-plane by setting one of the components to 0
163 // We compute p1 by stepping from p0 along a perpendicular to the normal
164 if (b) {
165 pts[0] = { 0, -c / b };
166 pts[1] = { b, pts[0].fY - a};
167 } else if (a) {
168 pts[0] = { -c / a, 0 };
169 pts[1] = { pts[0].fX + b, -a };
170 } else {
171 return false;
172 }
173
174 SkASSERT(SkScalarNearlyZero(this->operator()(pts[0].fX, pts[0].fY)));
175 SkASSERT(SkScalarNearlyZero(this->operator()(pts[1].fX, pts[1].fY)));
176 return true;
177 }
178
179 enum Result {
180 kAllNegative,
181 kAllPositive,
182 kMixed
183 };
testSkHalfPlane184 Result test(const SkRect& bounds) const {
185 SkPoint diagMin, diagMax;
186 if (fA >= 0) {
187 diagMin.fX = bounds.fLeft;
188 diagMax.fX = bounds.fRight;
189 } else {
190 diagMin.fX = bounds.fRight;
191 diagMax.fX = bounds.fLeft;
192 }
193 if (fB >= 0) {
194 diagMin.fY = bounds.fTop;
195 diagMax.fY = bounds.fBottom;
196 } else {
197 diagMin.fY = bounds.fBottom;
198 diagMax.fY = bounds.fTop;
199 }
200 SkScalar test = this->eval(diagMin.fX, diagMin.fY);
201 SkScalar sign = test*this->eval(diagMax.fX, diagMin.fY);
202 if (sign > 0) {
203 // the path is either all on one side of the half-plane or the other
204 if (test < 0) {
205 return kAllNegative;
206 } else {
207 return kAllPositive;
208 }
209 }
210 return kMixed;
211 }
212 };
213
214 #include "src/core/SkEdgeClipper.h"
215
clip(const SkPath & path,SkPoint p0,SkPoint p1,SkPath * clippedPath)216 static void clip(const SkPath& path, SkPoint p0, SkPoint p1, SkPath* clippedPath) {
217 SkMatrix mx, inv;
218 SkVector v = p1 - p0;
219 mx.setAll(v.fX, -v.fY, p0.fX,
220 v.fY, v.fX, p0.fY,
221 0, 0, 1);
222 SkAssertResult(mx.invert(&inv));
223
224 SkPath rotated;
225 path.transform(inv, &rotated);
226
227 SkScalar big = 1e28f;
228 SkRect clip = {-big, 0, big, big };
229
230 struct Rec {
231 SkPath* fResult;
232 SkPoint fPrev;
233 } rec = { clippedPath, {0, 0} };
234
235 SkEdgeClipper::ClipPath(rotated, clip, false,
236 [](SkEdgeClipper* clipper, bool newCtr, void* ctx) {
237 Rec* rec = (Rec*)ctx;
238
239 bool addLineTo = false;
240 SkPoint pts[4];
241 SkPath::Verb verb;
242 while ((verb = clipper->next(pts)) != SkPath::kDone_Verb) {
243 if (newCtr) {
244 rec->fResult->moveTo(pts[0]);
245 rec->fPrev = pts[0];
246 newCtr = false;
247 }
248
249 if (addLineTo || pts[0] != rec->fPrev) {
250 rec->fResult->lineTo(pts[0]);
251 }
252
253 switch (verb) {
254 case SkPath::kLine_Verb:
255 rec->fResult->lineTo(pts[1]);
256 rec->fPrev = pts[1];
257 break;
258 case SkPath::kQuad_Verb:
259 rec->fResult->quadTo(pts[1], pts[2]);
260 rec->fPrev = pts[2];
261 break;
262 case SkPath::kCubic_Verb:
263 rec->fResult->cubicTo(pts[1], pts[2], pts[3]);
264 rec->fPrev = pts[3];
265 break;
266 default: break;
267 }
268 addLineTo = true;
269 }
270 }, &rec);
271
272 rec.fResult->transform(mx);
273 }
274
draw_halfplane(SkCanvas * canvas,SkPoint p0,SkPoint p1,SkColor c)275 static void draw_halfplane(SkCanvas* canvas, SkPoint p0, SkPoint p1, SkColor c) {
276 SkVector v = p1 - p0;
277 p0 = p0 - v * 1000;
278 p1 = p1 + v * 1000;
279
280 SkPaint paint;
281 paint.setColor(c);
282 canvas->drawLine(p0, p1, paint);
283 }
284
make_path()285 static SkPath make_path() {
286 SkRandom rand;
287 auto rand_pt = [&rand]() {
288 auto x = rand.nextF();
289 auto y = rand.nextF();
290 return SkPoint{x * 400, y * 400};
291 };
292
293 SkPath path;
294 for (int i = 0; i < 4; ++i) {
295 SkPoint pts[6];
296 for (auto& p : pts) {
297 p = rand_pt();
298 }
299 path.moveTo(pts[0]).quadTo(pts[1], pts[2]).quadTo(pts[3], pts[4]).lineTo(pts[5]);
300 }
301 return path;
302 }
303
304 class HalfPlaneView : public Sample {
305 SkPoint fPts[2];
306 SkPath fPath;
307
name()308 SkString name() override { return SkString("halfplane"); }
309
onOnceBeforeDraw()310 void onOnceBeforeDraw() override {
311 fPts[0] = {0, 0};
312 fPts[1] = {3, 2};
313 fPath = make_path();
314 }
315
onDrawContent(SkCanvas * canvas)316 void onDrawContent(SkCanvas* canvas) override {
317 SkPaint paint;
318
319 paint.setColor({0.5f, 0.5f, 0.5f, 1.0f}, nullptr);
320 canvas->drawPath(fPath, paint);
321
322 paint.setColor({0, 0, 0, 1}, nullptr);
323
324 SkPath clippedPath;
325 clip(fPath, fPts[0], fPts[1], &clippedPath);
326 canvas->drawPath(clippedPath, paint);
327
328 draw_halfplane(canvas, fPts[0], fPts[1], SK_ColorRED);
329 }
330
onFindClickHandler(SkScalar x,SkScalar y,skui::ModifierKey modi)331 Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
332 return new Click;
333 }
334
onClick(Click * click)335 bool onClick(Click* click) override {
336 fPts[0] = click->fCurr;
337 fPts[1] = fPts[0] + SkPoint{3, 2};
338 return true;
339 }
340 };
DEF_SAMPLE(return new HalfPlaneView ();)341 DEF_SAMPLE( return new HalfPlaneView(); )
342
343 static void draw_halfplane(SkCanvas* canvas, const SkHalfPlane& p, SkColor c) {
344 SkPoint pts[2];
345 p.twoPts(pts);
346 draw_halfplane(canvas, pts[0], pts[1], c);
347 }
348
compute_half_planes(const SkMatrix & mx,SkScalar W,SkScalar H,SkHalfPlane planes[4])349 static void compute_half_planes(const SkMatrix& mx, SkScalar W, SkScalar H,
350 SkHalfPlane planes[4]) {
351 SkScalar a = mx[0], b = mx[1], c = mx[2],
352 d = mx[3], e = mx[4], f = mx[5],
353 g = mx[6], h = mx[7], i = mx[8];
354
355 planes[0] = { 2*g - 2*a/W, 2*h - 2*b/W, 2*i - 2*c/W };
356 planes[1] = { 2*a/W, 2*b/W, 2*c/W };
357 planes[2] = { 2*g - 2*d/H, 2*h - 2*e/H, 2*i - 2*f/H };
358 planes[3] = { 2*d/H, 2*e/H, 2*f/H };
359 }
360
361 class HalfPlaneView2 : public Sample {
362 SkPoint fPts[4];
363 SkPath fPath;
364
name()365 SkString name() override { return SkString("halfplane2"); }
366
onOnceBeforeDraw()367 void onOnceBeforeDraw() override {
368 fPath = make_path();
369 SkRect r = fPath.getBounds();
370 r.toQuad(fPts);
371 }
372
onDrawContent(SkCanvas * canvas)373 void onDrawContent(SkCanvas* canvas) override {
374 SkMatrix mx;
375 {
376 SkRect r = fPath.getBounds();
377 SkPoint src[4];
378 r.toQuad(src);
379 mx.setPolyToPoly(src, fPts, 4);
380 }
381
382 SkPaint paint;
383 canvas->drawPath(fPath, paint);
384
385 canvas->save();
386 canvas->concat(mx);
387 paint.setColor(0x40FF0000);
388 canvas->drawPath(fPath, paint);
389 canvas->restore();
390
391 // draw the frame
392 paint.setStrokeWidth(10);
393 paint.setColor(SK_ColorGREEN);
394 canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPts, paint);
395
396 // draw the half-planes
397 SkHalfPlane planes[4];
398 compute_half_planes(mx, 400, 400, planes);
399 for (auto& p : planes) {
400 draw_halfplane(canvas, p, SK_ColorRED);
401 }
402 }
403
onFindClickHandler(SkScalar x,SkScalar y,skui::ModifierKey modi)404 Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
405 SkScalar r = 8;
406 SkRect rect = SkRect::MakeXYWH(x - r, y - r, 2*r, 2*r);
407 for (int i = 0; i < 4; ++i) {
408 if (rect.contains(fPts[i].fX, fPts[i].fY)) {
409 Click* c = new Click;
410 c->fMeta.setS32("index", i);
411 return c;
412 }
413 }
414 return nullptr;
415 }
416
onClick(Click * click)417 bool onClick(Click* click) override {
418 int32_t index;
419 SkAssertResult(click->fMeta.findS32("index", &index));
420 SkASSERT(index >= 0 && index < 4);
421 fPts[index] = click->fCurr;
422 return true;
423 }
424 };
DEF_SAMPLE(return new HalfPlaneView2 ();)425 DEF_SAMPLE( return new HalfPlaneView2(); )
426
427 static SkM44 inv(const SkM44& m) {
428 SkM44 inverse;
429 SkAssertResult(m.invert(&inverse));
430 return inverse;
431 }
432
half_plane_w0(const SkMatrix & m)433 static SkHalfPlane half_plane_w0(const SkMatrix& m) {
434 return { m[SkMatrix::kMPersp0], m[SkMatrix::kMPersp1], m[SkMatrix::kMPersp2] - 0.05f };
435 }
436
437 class SampleCameraView : public Sample {
438 float fNear = 0.05f;
439 float fFar = 4;
440 float fAngle = SK_ScalarPI / 4;
441
442 SkV3 fEye { 0, 0, 1.0f/tan(fAngle/2) - 1 };
443 SkV3 fCOA { 0, 0, 0 };
444 SkV3 fUp { 0, 1, 0 };
445
446 SkM44 fRot;
447 SkV3 fTrans;
448
rotate(float x,float y,float z)449 void rotate(float x, float y, float z) {
450 SkM44 r;
451 if (x) {
452 r.setRotateUnit({1, 0, 0}, x);
453 } else if (y) {
454 r.setRotateUnit({0, 1, 0}, y);
455 } else {
456 r.setRotateUnit({0, 0, 1}, z);
457 }
458 fRot = r * fRot;
459 }
460
461 public:
get44(const SkRect & r) const462 SkM44 get44(const SkRect& r) const {
463 SkScalar w = r.width();
464 SkScalar h = r.height();
465
466 SkM44 camera = Sk3LookAt(fEye, fCOA, fUp),
467 perspective = Sk3Perspective(fNear, fFar, fAngle),
468 translate = SkM44::Translate(fTrans.x, fTrans.y, fTrans.z),
469 viewport = SkM44::Translate(r.centerX(), r.centerY(), 0) *
470 SkM44::Scale(w*0.5f, h*0.5f, 1);
471
472 return viewport * perspective * camera * translate * fRot * inv(viewport);
473 }
474
onChar(SkUnichar uni)475 bool onChar(SkUnichar uni) override {
476 float delta = SK_ScalarPI / 30;
477 switch (uni) {
478 case '8': this->rotate( delta, 0, 0); return true;
479 case '2': this->rotate(-delta, 0, 0); return true;
480 case '4': this->rotate(0, delta, 0); return true;
481 case '6': this->rotate(0, -delta, 0); return true;
482 case '-': this->rotate(0, 0, delta); return true;
483 case '+': this->rotate(0, 0, -delta); return true;
484
485 case 'i': fTrans.z += 0.1f; SkDebugf("z %g\n", fTrans.z); return true;
486 case 'k': fTrans.z -= 0.1f; SkDebugf("z %g\n", fTrans.z); return true;
487
488 case 'n': fNear += 0.1f; SkDebugf("near %g\n", fNear); return true;
489 case 'N': fNear -= 0.1f; SkDebugf("near %g\n", fNear); return true;
490 case 'f': fFar += 0.1f; SkDebugf("far %g\n", fFar); return true;
491 case 'F': fFar -= 0.1f; SkDebugf("far %g\n", fFar); return true;
492 default: break;
493 }
494 return false;
495 }
496 };
497
498 class HalfPlaneView3 : public SampleCameraView {
499 SkPath fPath;
500 sk_sp<SkShader> fShader;
501 bool fShowUnclipped = false;
502
name()503 SkString name() override { return SkString("halfplane3"); }
504
onOnceBeforeDraw()505 void onOnceBeforeDraw() override {
506 fPath = make_path();
507 fShader = GetResourceAsImage("images/mandrill_128.png")
508 ->makeShader(SkMatrix::MakeScale(3, 3));
509 }
510
onChar(SkUnichar uni)511 bool onChar(SkUnichar uni) override {
512 switch (uni) {
513 case 'u': fShowUnclipped = !fShowUnclipped; return true;
514 default: break;
515 }
516 return this->SampleCameraView::onChar(uni);
517 }
518
onDrawContent(SkCanvas * canvas)519 void onDrawContent(SkCanvas* canvas) override {
520 SkM44 mx = this->get44({0, 0, 400, 400});
521
522 SkPaint paint;
523 paint.setColor({0.75, 0.75, 0.75, 1});
524 canvas->drawPath(fPath, paint);
525
526 paint.setShader(fShader);
527
528 if (fShowUnclipped) {
529 canvas->save();
530 canvas->concat44(mx);
531 paint.setAlphaf(0.33f);
532 canvas->drawPath(fPath, paint);
533 paint.setAlphaf(1.f);
534 canvas->restore();
535 }
536
537
538 SkColor planeColor = SK_ColorBLUE;
539 SkPath clippedPath, *path = &fPath;
540 if (SkPathPriv::PerspectiveClip(fPath, mx.asM33(), &clippedPath)) {
541 path = &clippedPath;
542 planeColor = SK_ColorRED;
543 }
544 canvas->save();
545 canvas->concat44(mx);
546 canvas->drawPath(*path, paint);
547 canvas->restore();
548
549 SkHalfPlane hpw = half_plane_w0(mx.asM33());
550 draw_halfplane(canvas, hpw, planeColor);
551 }
552 };
553 DEF_SAMPLE( return new HalfPlaneView3(); )
554
555 class HalfPlaneCoons : public SampleCameraView {
556 SkPoint fPatch[12];
557 SkColor fColors[4] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorBLACK };
558 SkPoint fTex[4] = {{0, 0}, {256, 0}, {256, 256}, {0, 256}};
559 sk_sp<SkShader> fShader;
560
561 bool fShowHandles = false;
562 bool fShowSkeleton = false;
563 bool fShowTex = false;
564
name()565 SkString name() override { return SkString("halfplane-coons"); }
566
onOnceBeforeDraw()567 void onOnceBeforeDraw() override {
568 fPatch[0] = { 0, 0 };
569 fPatch[1] = { 100, 0 };
570 fPatch[2] = { 200, 0 };
571 fPatch[3] = { 300, 0 };
572 fPatch[4] = { 300, 100 };
573 fPatch[5] = { 300, 200 };
574 fPatch[6] = { 300, 300 };
575 fPatch[7] = { 200, 300 };
576 fPatch[8] = { 100, 300 };
577 fPatch[9] = { 0, 300 };
578 fPatch[10] = { 0, 200 };
579 fPatch[11] = { 0, 100 };
580
581 fShader = GetResourceAsImage("images/mandrill_256.png")->makeShader();
582 }
583
onDrawContent(SkCanvas * canvas)584 void onDrawContent(SkCanvas* canvas) override {
585 SkPaint paint;
586
587 canvas->save();
588 canvas->concat44(this->get44({0, 0, 300, 300}));
589
590 const SkPoint* tex = nullptr;
591 const SkColor* col = nullptr;
592 if (!fShowSkeleton) {
593 if (fShowTex) {
594 paint.setShader(fShader);
595 tex = fTex;
596 } else {
597 col = fColors;
598 }
599 }
600 canvas->drawPatch(fPatch, col, tex, SkBlendMode::kSrc, paint);
601 paint.setShader(nullptr);
602
603 if (fShowHandles) {
604 paint.setAntiAlias(true);
605 paint.setStrokeCap(SkPaint::kRound_Cap);
606 paint.setStrokeWidth(8);
607 canvas->drawPoints(SkCanvas::kPoints_PointMode, 12, fPatch, paint);
608 paint.setColor(SK_ColorWHITE);
609 paint.setStrokeWidth(6);
610 canvas->drawPoints(SkCanvas::kPoints_PointMode, 12, fPatch, paint);
611 }
612
613 canvas->restore();
614 }
615
onFindClickHandler(SkScalar x,SkScalar y,skui::ModifierKey modi)616 Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
617 auto dist = [](SkPoint a, SkPoint b) { return (b - a).length(); };
618
619 const float tol = 15;
620 for (int i = 0; i < 12; ++i) {
621 if (dist({x,y}, fPatch[i]) <= tol) {
622 Click* c = new Click;
623 c->fMeta.setS32("index", i);
624 return c;
625 }
626 }
627 return nullptr;
628 }
629
onClick(Click * click)630 bool onClick(Click* click) override {
631 int32_t index;
632 SkAssertResult(click->fMeta.findS32("index", &index));
633 SkASSERT(index >= 0 && index < 12);
634 fPatch[index] = click->fCurr;
635 return true;
636 }
637
onChar(SkUnichar uni)638 bool onChar(SkUnichar uni) override {
639 switch (uni) {
640 case 'h': fShowHandles = !fShowHandles; return true;
641 case 'k': fShowSkeleton = !fShowSkeleton; return true;
642 case 't': fShowTex = !fShowTex; return true;
643 default: break;
644 }
645 return this->SampleCameraView::onChar(uni);
646 }
647
648 };
649 DEF_SAMPLE( return new HalfPlaneCoons(); )
650
