blob: 97be84495ae4107d4bc4f9e98b74e5e65c8ccaf6 [file] [log] [blame]
Michael Ludwigd20cf332019-01-30 14:38:59 -05001/*
2 * Copyright 2019 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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "samplecode/Sample.h"
Michael Ludwigd20cf332019-01-30 14:38:59 -05009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/core/SkCanvas.h"
11#include "include/core/SkColorFilter.h"
12#include "include/core/SkFont.h"
13#include "include/core/SkImage.h"
14#include "include/core/SkPath.h"
15#include "include/core/SkSurface.h"
Michael Ludwigd20cf332019-01-30 14:38:59 -050016
17namespace skiagm {
18
19class ShapeRenderer : public SkRefCntBase {
20public:
21 static constexpr SkScalar kTileWidth = 20.f;
22 static constexpr SkScalar kTileHeight = 20.f;
23
Michael Ludwigd20cf332019-01-30 14:38:59 -050024 // Draw the shape, limited to kTileWidth x kTileHeight. It must apply the local subpixel (tx,
25 // ty) translation and rotation by angle. Prior to these transform adjustments, the SkCanvas
26 // will only have pixel aligned translations (these are separated to make super-sampling
27 // renderers easier).
28 virtual void draw(SkCanvas* canvas, SkPaint* paint,
29 SkScalar tx, SkScalar ty, SkScalar angle) = 0;
30
31 virtual SkString name() = 0;
32
33 virtual sk_sp<ShapeRenderer> toHairline() = 0;
34
35 void applyLocalTransform(SkCanvas* canvas, SkScalar tx, SkScalar ty, SkScalar angle) {
36 canvas->translate(tx, ty);
37 canvas->rotate(angle, kTileWidth / 2.f, kTileHeight / 2.f);
38 }
39};
40
41class RectRenderer : public ShapeRenderer {
42public:
43 static sk_sp<ShapeRenderer> Make() {
44 return sk_sp<ShapeRenderer>(new RectRenderer());
45 }
46
47 SkString name() override { return SkString("rect"); }
48
49 sk_sp<ShapeRenderer> toHairline() override {
50 // Not really available but can't return nullptr
51 return Make();
52 }
53
54 void draw(SkCanvas* canvas, SkPaint* paint, SkScalar tx, SkScalar ty, SkScalar angle) override {
55 SkScalar width = paint->getStrokeWidth();
56 paint->setStyle(SkPaint::kFill_Style);
57
58 this->applyLocalTransform(canvas, tx, ty, angle);
59 canvas->drawRect(SkRect::MakeLTRB(kTileWidth / 2.f - width / 2.f, 2.f,
60 kTileWidth / 2.f + width / 2.f, kTileHeight - 2.f),
61 *paint);
62 }
63
64private:
65 RectRenderer() {}
66
John Stiles7571f9e2020-09-02 22:42:33 -040067 using INHERITED = ShapeRenderer;
Michael Ludwigd20cf332019-01-30 14:38:59 -050068};
69
70class PathRenderer : public ShapeRenderer {
71public:
72 static sk_sp<ShapeRenderer> MakeLine(bool hairline = false) {
73 return MakeCurve(0.f, hairline);
74 }
75
76 static sk_sp<ShapeRenderer> MakeLines(SkScalar depth, bool hairline = false) {
77 return MakeCurve(-depth, hairline);
78 }
79
80 static sk_sp<ShapeRenderer> MakeCurve(SkScalar depth, bool hairline = false) {
81 return sk_sp<ShapeRenderer>(new PathRenderer(depth, hairline));
82 }
83
84 SkString name() override {
85 SkString name;
86 if (fHairline) {
87 name.append("hairline");
88 if (fDepth > 0.f) {
89 name.appendf("-curve-%.2f", fDepth);
90 }
91 } else if (fDepth > 0.f) {
92 name.appendf("curve-%.2f", fDepth);
93 } else if (fDepth < 0.f) {
94 name.appendf("line-%.2f", -fDepth);
95 } else {
96 name.append("line");
97 }
98
99 return name;
100 }
101
102 sk_sp<ShapeRenderer> toHairline() override {
103 return sk_sp<ShapeRenderer>(new PathRenderer(fDepth, true));
104 }
105
106 void draw(SkCanvas* canvas, SkPaint* paint, SkScalar tx, SkScalar ty, SkScalar angle) override {
107 SkPath path;
108 path.moveTo(kTileWidth / 2.f, 2.f);
109
110 if (fDepth > 0.f) {
111 path.quadTo(kTileWidth / 2.f + fDepth, kTileHeight / 2.f,
112 kTileWidth / 2.f, kTileHeight - 2.f);
113 } else {
114 if (fDepth < 0.f) {
115 path.lineTo(kTileWidth / 2.f + fDepth, kTileHeight / 2.f);
116 }
117 path.lineTo(kTileWidth / 2.f, kTileHeight - 2.f);
118 }
119
120 if (fHairline) {
121 // Fake thinner hairlines by making it transparent, conflating coverage and alpha
122 SkColor4f color = paint->getColor4f();
123 SkScalar width = paint->getStrokeWidth();
124 if (width > 1.f) {
125 // Can't emulate width larger than a pixel
126 return;
127 }
128 paint->setColor4f({color.fR, color.fG, color.fB, width}, nullptr);
129 paint->setStrokeWidth(0.f);
130 }
131
132 // Adding round caps forces Ganesh to use the path renderer for lines instead of converting
133 // them to rectangles (which are already explicitly tested). However, when not curved, the
Michael Ludwig2686d692020-04-17 20:21:37 +0000134 // GrStyledShape will still find a way to turn it into a rrect draw so it doesn't hit the
Michael Ludwigd20cf332019-01-30 14:38:59 -0500135 // path renderer in that condition.
136 paint->setStrokeCap(SkPaint::kRound_Cap);
137 paint->setStrokeJoin(SkPaint::kMiter_Join);
138 paint->setStyle(SkPaint::kStroke_Style);
139
140 this->applyLocalTransform(canvas, tx, ty, angle);
141 canvas->drawPath(path, *paint);
142 }
143
144private:
145 SkScalar fDepth; // 0.f to make a line, otherwise outset of curve from end points
146 bool fHairline;
147
148 PathRenderer(SkScalar depth, bool hairline)
149 : fDepth(depth)
150 , fHairline(hairline) {}
151
John Stiles7571f9e2020-09-02 22:42:33 -0400152 using INHERITED = ShapeRenderer;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500153};
154
155class OffscreenShapeRenderer : public ShapeRenderer {
156public:
157 ~OffscreenShapeRenderer() override = default;
158
159 static sk_sp<OffscreenShapeRenderer> Make(sk_sp<ShapeRenderer> renderer, int supersample,
160 bool forceRaster = false) {
161 SkASSERT(supersample > 0);
162 return sk_sp<OffscreenShapeRenderer>(new OffscreenShapeRenderer(std::move(renderer),
163 supersample, forceRaster));
164 }
165
166 SkString name() override {
167 SkString name = fRenderer->name();
168 if (fSupersampleFactor != 1) {
169 name.prependf("%dx-", fSupersampleFactor * fSupersampleFactor);
170 }
171 return name;
172 }
173
174 sk_sp<ShapeRenderer> toHairline() override {
175 return Make(fRenderer->toHairline(), fSupersampleFactor, fForceRasterBackend);
176 }
177
178 void draw(SkCanvas* canvas, SkPaint* paint, SkScalar tx, SkScalar ty, SkScalar angle) override {
179 // Subpixel translation+angle are applied in the offscreen buffer
180 this->prepareBuffer(canvas, paint, tx, ty, angle);
181 this->redraw(canvas);
182 }
183
184 // Exposed so that it's easy to fill the offscreen buffer, then draw zooms/filters of it before
185 // drawing the original scale back into the canvas.
186 void prepareBuffer(SkCanvas* canvas, SkPaint* paint, SkScalar tx, SkScalar ty, SkScalar angle) {
187 auto info = SkImageInfo::Make(fSupersampleFactor * kTileWidth,
188 fSupersampleFactor * kTileHeight,
189 kRGBA_8888_SkColorType, kPremul_SkAlphaType);
190 auto surface = fForceRasterBackend ? SkSurface::MakeRaster(info)
191 : canvas->makeSurface(info);
192
193 surface->getCanvas()->save();
194 // Make fully transparent so it is easy to determine pixels that are touched by partial cov.
195 surface->getCanvas()->clear(SK_ColorTRANSPARENT);
196 // Set up scaling to fit supersampling amount
197 surface->getCanvas()->scale(fSupersampleFactor, fSupersampleFactor);
198 fRenderer->draw(surface->getCanvas(), paint, tx, ty, angle);
199 surface->getCanvas()->restore();
200
201 // Save image so it can be drawn zoomed in or to visualize touched pixels; only valid until
202 // the next call to draw()
203 fLastRendered = surface->makeImageSnapshot();
204 }
205
206 void redraw(SkCanvas* canvas, SkScalar scale = 1.f, bool debugMode = false) {
207 SkASSERT(fLastRendered);
208 // Use medium quality filter to get mipmaps when drawing smaller, or use nearest filtering
209 // when upscaling
210 SkPaint blit;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500211 if (debugMode) {
212 // Makes anything that's > 1/255 alpha fully opaque and sets color to medium green.
Mike Reede869a1e2019-04-30 12:18:54 -0400213 static constexpr float kFilter[] = {
214 0.f, 0.f, 0.f, 0.f, 16.f/255,
215 0.f, 0.f, 0.f, 0.f, 200.f/255,
216 0.f, 0.f, 0.f, 0.f, 16.f/255,
Michael Ludwigd20cf332019-01-30 14:38:59 -0500217 0.f, 0.f, 0.f, 255.f, 0.f
218 };
219
Mike Reede869a1e2019-04-30 12:18:54 -0400220 blit.setColorFilter(SkColorFilters::Matrix(kFilter));
Michael Ludwigd20cf332019-01-30 14:38:59 -0500221 }
222
223 canvas->scale(scale, scale);
Mike Reed839eef32020-12-23 11:18:24 -0500224 canvas->drawImageRect(fLastRendered.get(),
225 SkRect::MakeWH(kTileWidth, kTileHeight),
226 SkRect::MakeWH(kTileWidth, kTileHeight),
227 SkSamplingOptions(scale > 1.f ? kNone_SkFilterQuality
228 : kMedium_SkFilterQuality),
Mike Reed4f23dec2020-12-30 14:22:42 +0000229 &blit,
230 SkCanvas::kFast_SrcRectConstraint);
Michael Ludwigd20cf332019-01-30 14:38:59 -0500231 }
232
233private:
234 bool fForceRasterBackend;
235 sk_sp<SkImage> fLastRendered;
236 sk_sp<ShapeRenderer> fRenderer;
237 int fSupersampleFactor;
238
239 OffscreenShapeRenderer(sk_sp<ShapeRenderer> renderer, int supersample, bool forceRaster)
240 : fForceRasterBackend(forceRaster)
241 , fLastRendered(nullptr)
242 , fRenderer(std::move(renderer))
243 , fSupersampleFactor(supersample) { }
244
John Stiles7571f9e2020-09-02 22:42:33 -0400245 using INHERITED = ShapeRenderer;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500246};
247
248class ThinAASample : public Sample {
249public:
250 ThinAASample() {
251 this->setBGColor(0xFFFFFFFF);
252 }
253
254protected:
255 void onOnceBeforeDraw() override {
256 // Setup all base renderers
257 fShapes.push_back(RectRenderer::Make());
258 fShapes.push_back(PathRenderer::MakeLine());
259 fShapes.push_back(PathRenderer::MakeLines(4.f)); // 2 segments
260 fShapes.push_back(PathRenderer::MakeCurve(2.f)); // Shallow curve
261 fShapes.push_back(PathRenderer::MakeCurve(8.f)); // Deep curve
262
263 for (int i = 0; i < fShapes.count(); ++i) {
264 fNative.push_back(OffscreenShapeRenderer::Make(fShapes[i], 1));
265 fRaster.push_back(OffscreenShapeRenderer::Make(fShapes[i], 1, /* raster */ true));
266 fSS4.push_back(OffscreenShapeRenderer::Make(fShapes[i], 4)); // 4x4 -> 16 samples
267 fSS16.push_back(OffscreenShapeRenderer::Make(fShapes[i], 8)); // 8x8 -> 64 samples
268
269 fHairline.push_back(OffscreenShapeRenderer::Make(fRaster[i]->toHairline(), 1));
270 }
271
272 // Start it at something subpixel
273 fStrokeWidth = 0.5f;
274
275 fSubpixelX = 0.f;
276 fSubpixelY = 0.f;
277 fAngle = 0.f;
278
279 fCurrentStage = AnimStage::kMoveLeft;
280 fLastFrameTime = -1.f;
281
282 // Don't animate in the beginning
283 fAnimTranslate = false;
284 fAnimRotate = false;
285 }
286
287 void onDrawContent(SkCanvas* canvas) override {
288 // Move away from screen edge and add instructions
289 SkPaint text;
290 SkFont font(nullptr, 12);
291 canvas->translate(60.f, 20.f);
292 canvas->drawString("Each row features a rendering command under different AA strategies. "
293 "Native refers to the current backend of the viewer, e.g. OpenGL.",
294 0, 0, font, text);
295
296 canvas->drawString(SkStringPrintf("Stroke width: %.2f ('-' to decrease, '=' to increase)",
297 fStrokeWidth), 0, 24, font, text);
298 canvas->drawString(SkStringPrintf("Rotation: %.3f ('r' to animate, 'y' sets to 90, 'u' sets"
299 " to 0, 'space' adds 15)", fAngle), 0, 36, font, text);
300 canvas->drawString(SkStringPrintf("Translation: %.3f, %.3f ('t' to animate)",
301 fSubpixelX, fSubpixelY), 0, 48, font, text);
302
303 canvas->translate(0.f, 100.f);
304
305 // Draw with surface matching current viewer surface type
306 this->drawShapes(canvas, "Native", 0, fNative);
307
308 // Draw with forced raster backend so it's easy to compare side-by-side
309 this->drawShapes(canvas, "Raster", 1, fRaster);
310
311 // Draw paths as hairlines + alpha hack
312 this->drawShapes(canvas, "Hairline", 2, fHairline);
313
314 // Draw at 4x supersampling in bottom left
315 this->drawShapes(canvas, "SSx16", 3, fSS4);
316
317 // And lastly 16x supersampling in bottom right
318 this->drawShapes(canvas, "SSx64", 4, fSS16);
319 }
320
Hal Canary41248072019-07-11 16:32:53 -0400321 bool onAnimate(double nanos) override {
322 SkScalar t = 1e-9 * nanos;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500323 SkScalar dt = fLastFrameTime < 0.f ? 0.f : t - fLastFrameTime;
324 fLastFrameTime = t;
325
326 if (!fAnimRotate && !fAnimTranslate) {
327 // Keep returning true so that the last frame time is tracked
328 fLastFrameTime = -1.f;
329 return false;
330 }
331
332 switch(fCurrentStage) {
333 case AnimStage::kMoveLeft:
334 fSubpixelX += 2.f * dt;
335 if (fSubpixelX >= 1.f) {
336 fSubpixelX = 1.f;
337 fCurrentStage = AnimStage::kMoveDown;
338 }
339 break;
340 case AnimStage::kMoveDown:
341 fSubpixelY += 2.f * dt;
342 if (fSubpixelY >= 1.f) {
343 fSubpixelY = 1.f;
344 fCurrentStage = AnimStage::kMoveRight;
345 }
346 break;
347 case AnimStage::kMoveRight:
348 fSubpixelX -= 2.f * dt;
349 if (fSubpixelX <= -1.f) {
350 fSubpixelX = -1.f;
351 fCurrentStage = AnimStage::kMoveUp;
352 }
353 break;
354 case AnimStage::kMoveUp:
355 fSubpixelY -= 2.f * dt;
356 if (fSubpixelY <= -1.f) {
357 fSubpixelY = -1.f;
358 fCurrentStage = fAnimRotate ? AnimStage::kRotate : AnimStage::kMoveLeft;
359 }
360 break;
361 case AnimStage::kRotate: {
362 SkScalar newAngle = fAngle + dt * 15.f;
363 bool completed = SkScalarMod(newAngle, 15.f) < SkScalarMod(fAngle, 15.f);
364 fAngle = SkScalarMod(newAngle, 360.f);
365 if (completed) {
366 // Make sure we're on a 15 degree boundary
367 fAngle = 15.f * SkScalarRoundToScalar(fAngle / 15.f);
368 if (fAnimTranslate) {
369 fCurrentStage = this->getTranslationStage();
370 }
371 }
372 } break;
373 }
374
375 return true;
376 }
377
Hal Canary8a027312019-07-03 10:55:44 -0400378 SkString name() override { return SkString("Thin-AA"); }
Michael Ludwigd20cf332019-01-30 14:38:59 -0500379
Hal Canary6cc65e12019-07-03 15:53:04 -0400380 bool onChar(SkUnichar key) override {
Michael Ludwigd20cf332019-01-30 14:38:59 -0500381 switch(key) {
382 case 't':
383 // Toggle translation animation.
384 fAnimTranslate = !fAnimTranslate;
385 if (!fAnimTranslate && fAnimRotate && fCurrentStage != AnimStage::kRotate) {
386 // Turned off an active translation so go to rotating
387 fCurrentStage = AnimStage::kRotate;
388 } else if (fAnimTranslate && !fAnimRotate &&
389 fCurrentStage == AnimStage::kRotate) {
390 // Turned on translation, rotation had been paused too, so reset the stage
391 fCurrentStage = this->getTranslationStage();
392 }
393 return true;
394 case 'r':
395 // Toggle rotation animation.
396 fAnimRotate = !fAnimRotate;
397 if (!fAnimRotate && fAnimTranslate && fCurrentStage == AnimStage::kRotate) {
398 // Turned off an active rotation so go back to translation
399 fCurrentStage = this->getTranslationStage();
400 } else if (fAnimRotate && !fAnimTranslate &&
401 fCurrentStage != AnimStage::kRotate) {
402 // Turned on rotation, translation had been paused too, so reset to rotate
403 fCurrentStage = AnimStage::kRotate;
404 }
405 return true;
406 case 'u': fAngle = 0.f; return true;
407 case 'y': fAngle = 90.f; return true;
408 case ' ': fAngle = SkScalarMod(fAngle + 15.f, 360.f); return true;
Brian Osman116b33e2020-02-05 13:34:09 -0500409 case '-': fStrokeWidth = std::max(0.1f, fStrokeWidth - 0.05f); return true;
410 case '=': fStrokeWidth = std::min(1.f, fStrokeWidth + 0.05f); return true;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500411 }
Hal Canary6cc65e12019-07-03 15:53:04 -0400412 return false;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500413 }
414
415private:
416 // Base renderers that get wrapped on the offscreen renderers so that they can be transformed
417 // for visualization, or supersampled.
418 SkTArray<sk_sp<ShapeRenderer>> fShapes;
419
420 SkTArray<sk_sp<OffscreenShapeRenderer>> fNative;
421 SkTArray<sk_sp<OffscreenShapeRenderer>> fRaster;
422 SkTArray<sk_sp<OffscreenShapeRenderer>> fHairline;
423 SkTArray<sk_sp<OffscreenShapeRenderer>> fSS4;
424 SkTArray<sk_sp<OffscreenShapeRenderer>> fSS16;
425
426 SkScalar fStrokeWidth;
427
428 // Animated properties to stress the AA algorithms
429 enum class AnimStage {
430 kMoveRight, kMoveDown, kMoveLeft, kMoveUp, kRotate
431 } fCurrentStage;
432 SkScalar fLastFrameTime;
433 bool fAnimRotate;
434 bool fAnimTranslate;
435
436 // Current frame's animation state
437 SkScalar fSubpixelX;
438 SkScalar fSubpixelY;
439 SkScalar fAngle;
440
441 AnimStage getTranslationStage() {
442 // For paused translations (i.e. fAnimTranslate toggled while translating), the current
443 // stage moves to kRotate, but when restarting the translation animation, we want to
444 // go back to where we were without losing any progress.
445 if (fSubpixelX > -1.f) {
446 if (fSubpixelX >= 1.f) {
447 // Can only be moving down on right edge, given our transition states
448 return AnimStage::kMoveDown;
449 } else if (fSubpixelY > 0.f) {
450 // Can only be moving right along top edge
451 return AnimStage::kMoveRight;
452 } else {
453 // Must be moving left along bottom edge
454 return AnimStage::kMoveLeft;
455 }
456 } else {
457 // Moving up along the left edge, or is at the very top so start moving left
458 return fSubpixelY > -1.f ? AnimStage::kMoveUp : AnimStage::kMoveLeft;
459 }
460 }
461
462 void drawShapes(SkCanvas* canvas, const char* name, int gridX,
463 SkTArray<sk_sp<OffscreenShapeRenderer>> shapes) {
464 SkAutoCanvasRestore autoRestore(canvas, /* save */ true);
465
466 for (int i = 0; i < shapes.count(); ++i) {
467 this->drawShape(canvas, name, gridX, shapes[i].get(), i == 0);
468 // drawShape positions the canvas properly for the next iteration
469 }
470 }
471
472 void drawShape(SkCanvas* canvas, const char* name, int gridX,
473 OffscreenShapeRenderer* shape, bool drawNameLabels) {
474 static constexpr SkScalar kZoomGridWidth = 8 * ShapeRenderer::kTileWidth + 8.f;
475 static constexpr SkRect kTile = SkRect::MakeWH(ShapeRenderer::kTileWidth,
476 ShapeRenderer::kTileHeight);
477 static constexpr SkRect kZoomTile = SkRect::MakeWH(8 * ShapeRenderer::kTileWidth,
478 8 * ShapeRenderer::kTileHeight);
479
480 // Labeling per shape and detailed labeling that isn't per-stroke
481 canvas->save();
482 SkPaint text;
483 SkFont font(nullptr, 12);
484
485 if (gridX == 0) {
486 SkString name = shape->name();
487 SkScalar centering = name.size() * 4.f; // ad-hoc
488
489 canvas->save();
490 canvas->translate(-10.f, 4 * ShapeRenderer::kTileHeight + centering);
491 canvas->rotate(-90.f);
492 canvas->drawString(shape->name(), 0.f, 0.f, font, text);
493 canvas->restore();
494 }
495 if (drawNameLabels) {
496 canvas->drawString(name, gridX * kZoomGridWidth, -10.f, font, text);
497 }
498 canvas->restore();
499
500 // Paints for outlines and actual shapes
501 SkPaint outline;
502 outline.setStyle(SkPaint::kStroke_Style);
503 SkPaint clear;
504 clear.setColor(SK_ColorWHITE);
505
506 SkPaint paint;
507 paint.setAntiAlias(true);
508 paint.setStrokeWidth(fStrokeWidth);
509
510 // Generate a saved image of the correct stroke width, but don't put it into the canvas
511 // yet since we want to draw the "original" size on top of the zoomed in version
512 shape->prepareBuffer(canvas, &paint, fSubpixelX, fSubpixelY, fAngle);
513
514 // Draw it at 8X zoom
515 SkScalar x = gridX * kZoomGridWidth;
516
517 canvas->save();
518 canvas->translate(x, 0.f);
519 canvas->drawRect(kZoomTile, outline);
520 shape->redraw(canvas, 8.0f);
521 canvas->restore();
522
523 // Draw the original
524 canvas->save();
525 canvas->translate(x + 4.f, 4.f);
526 canvas->drawRect(kTile, clear);
527 canvas->drawRect(kTile, outline);
528 shape->redraw(canvas, 1.f);
529 canvas->restore();
530
531 // Now redraw it into the coverage location (just to the right of the original scale)
532 canvas->save();
533 canvas->translate(x + ShapeRenderer::kTileWidth + 8.f, 4.f);
534 canvas->drawRect(kTile, clear);
535 canvas->drawRect(kTile, outline);
536 shape->redraw(canvas, 1.f, /* debug */ true);
537 canvas->restore();
538
539 // Lastly, shift the canvas translation down by 8 * kTH + padding for the next set of shapes
540 canvas->translate(0.f, 8.f * ShapeRenderer::kTileHeight + 20.f);
541 }
542
John Stiles7571f9e2020-09-02 22:42:33 -0400543 using INHERITED = Sample;
Michael Ludwigd20cf332019-01-30 14:38:59 -0500544};
545
546//////////////////////////////////////////////////////////////////////////////
547
548DEF_SAMPLE( return new ThinAASample; )
549
John Stilesa6841be2020-08-06 14:11:56 -0400550} // namespace skiagm