Refugee from Dead Machine 13: New version of the convex AA tessellator

gm/convex_all_line_paths.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
+#include "GrAAConvexTessellator.h"
 
 static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
     float angleStep = 360.0f / n, angle = 0.0f, sin, cos;
     if ((n % 2) == 1) {
         angle = angleStep/2.0f;
     }
 
     for (int i = 0; i < n; ++i) {
         sin = SkScalarSinCos(SkDegreesToRadians(angle), &cos);
         pts[i].fX = -sin * width;
         pts[i].fY = cos * height;
         angle += angleStep;
     }
 }
 
 namespace skiagm {
 
 // This GM is intended to exercise Ganesh's handling of convex line-only
 // paths
 class ConvexLineOnlyPathsGM : public GM {
 public:
     ConvexLineOnlyPathsGM() { 
         fOffset.set(0, SkScalarHalf(kMaxPathHeight));
-        this->setBGColor(0xFFFFFFFF);
+        this->setBGColor(0xFF404040);
     }
 
 protected:
     SkString onShortName() override { return SkString("convex-lineonly-paths"); }
     SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
     bool runAsBench() const override { return true; }
 
     static SkPath GetPath(int index, int offset, SkPath::Direction dir) {
         // narrow rect
         const SkPoint gPoints0[] = {
             { -1.5f, -50.0f },
             {  1.5f, -50.0f },
             {  1.5f,  50.0f },
             { -1.5f,  50.0f }
         };
         // narrow rect on an angle
         const SkPoint gPoints1[] = {
             { -50.0f, -49.0f },
             { -49.0f, -50.0f },
             {  50.0f,  49.0f },
             {  49.0f,  50.0f }
         };
         // trap - narrow on top - wide on bottom
         const SkPoint gPoints2[] = {
-            { -10.0f, -50.0f },
-            {  10.0f, -50.0f },
+            {  -2.0f, -50.0f },
+            {   2.0f, -50.0f },
             {  50.0f,  50.0f },
             { -50.0f,  50.0f }
         };
         // wide skewed rect
         const SkPoint gPoints3[] = {
             { -50.0f, -50.0f },
             {   0.0f, -50.0f },
             {  50.0f,  50.0f },
             {   0.0f,  50.0f }
         };
@@ skipping 54 matching lines @@
             { -25.00f,  50.00f },
             { -40.45f,  47.55f },
             { -54.39f,  40.45f },
             { -65.45f,  29.39f },
             { -72.55f,  15.45f },
             { -75.00f,   0.00f },
             { -72.55f, -15.45f },
             { -65.45f, -29.39f },
             { -54.39f, -40.45f },
             { -40.45f, -47.55f },
-            { -25.0f,  -50.0f },
+            { -25.0f,  -50.0f  },
             {  -9.55f, -47.55f },
             {   4.39f, -40.45f },
             {  75.00f,   0.00f }
         };
         // clipped triangle
         const SkPoint gPoints10[] = {
             { -10.0f, -50.0f },
             {  10.0f, -50.0f },
             {  50.0f,  31.0f },
             {  40.0f,  50.0f },
@@ skipping 132 matching lines @@
             canvas->save();
                 canvas->translate(center.fX, center.fY);
                 canvas->scale(scales[i], scales[i]);
                 paint.setColor(colors[i%2]);
                 canvas->drawPath(path, paint);
             canvas->restore();
         }
     }
 
     void onDraw(SkCanvas* canvas) override {
+#if 0
+        SkPath path = GetPath(8, 0, SkPath::kCCW_Direction);
+
+        SkMatrix m2;
+        m2.setScale(0.01f, 0.01f);
+//        m2.postTranslate(kGMWidth/2, kGMHeight/2);
+
+        path.transform(m2);
+
+        GrAAConvexTessellator result;
+        result.setTargetDepth(40.0f);
+
+        result.tessellate(SkMatrix::I(), path);
+
+        canvas->translate(kGMWidth/2, kGMHeight/2);
+        canvas->scale(400, 400);
+#if GR_AA_CONVEX_TESSELLATOR_VIZ
+        result.draw(canvas);
+#endif
+
+#else
         for (int i = 0; i < kNumPaths; ++i) {
             this->drawPath(canvas, i);
         }
 
         // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)
         {
             canvas->translate(356.0f, 50.0f);
 
             SkPaint p;
             p.setAntiAlias(true);
 
             SkPath p1;
             p1.moveTo(60.8522949f, 364.671021f);
             p1.lineTo(59.4380493f, 364.671021f);
             p1.lineTo(385.414276f, 690.647217f);
             p1.lineTo(386.121399f, 689.940125f);
             canvas->drawPath(p1, p);
         }
+#endif
     }
 
 private:
     static const int kNumPaths      = 20;
     static const int kMaxPathHeight = 100;
-    static const int kGMWidth       = 512;
-    static const int kGMHeight      = 512;
+    static const int kGMWidth       = 1024;
+    static const int kGMHeight      = 1024;
 
     SkPoint fOffset;        // the right edge of the last drawn path
 
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return SkNEW(ConvexLineOnlyPathsGM); )
 
 }