Fix for fat stroked roundrects.

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 1332 matching lines @@
 //   | |        | |
 //   | |        | |
 //   | |        | |
 //   |_|________|_|
 //   |_|________|_|
 //
 // For strokes, we don't draw the center quad.
 //
 // For circular roundrects, in the case where the stroke width is greater than twice
 // the corner radius (overstroke), we add additional geometry to mark out the rectangle
-// in the center:
+// in the center. The shared vertices are duplicated so we can set a different outer radius
+// for the fill calculation.
 //    ____________
 //   |_|________|_|
 //   | |\ ____ /| |
 //   | | |    | | |
 //   | | |____| | |
 //   |_|/______\|_|
 //   |_|________|_|
 //
 // We don't draw the center quad from the fill rect in this case.
 
 static const uint16_t gRRectOverstrokeIndices[] = {
     // overstroke quads
     // we place this at the beginning so that we can skip these indices when rendering normally
-    5, 6, 17, 5, 17, 16,
-    17, 6, 10, 17, 10, 19,
-    10, 9, 18, 10, 18, 19,
-    18, 9, 5, 18, 5, 16,
+    16, 17, 19, 16, 19, 18,
+    19, 17, 23, 19, 23, 21,
+    21, 23, 22, 21, 22, 20,
+    22, 16, 18, 22, 18, 20,
 
     // corners
     0, 1, 5, 0, 5, 4,
     2, 3, 7, 2, 7, 6,
     8, 9, 13, 8, 13, 12,
     10, 11, 15, 10, 15, 14,
 
     // edges
     1, 2, 6, 1, 6, 5,
     4, 5, 9, 4, 9, 8,
     6, 7, 11, 6, 11, 10,
     9, 10, 14, 9, 14, 13,
 
     // center
     // we place this at the end so that we can ignore these indices when not rendering as filled
     5, 6, 10, 5, 10, 9,
 };
 
 static const uint16_t* gRRectIndices = gRRectOverstrokeIndices + 6*4;
 
 // overstroke count is arraysize 
 static const int kIndicesPerOverstrokeRRect = SK_ARRAY_COUNT(gRRectOverstrokeIndices) - 6;
 static const int kIndicesPerFillRRect = kIndicesPerOverstrokeRRect - 6*4 + 6;
 static const int kIndicesPerStrokeRRect = kIndicesPerFillRRect - 6;
 static const int kVertsPerStandardRRect = 16;
-static const int kVertsPerOverstrokeRRect = 20;
+static const int kVertsPerOverstrokeRRect = 24;
 static const int kNumRRectsInIndexBuffer = 256;
 
 enum RRectType {
     kFill_RRectType,
     kStroke_RRectType,
     kOverstroke_RRectType
 };
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
 GR_DECLARE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
@@ skipping 197 matching lines @@
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fRight, yCoords[i]);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(1, yOuterRadii[i]);
                 verts->fOuterRadius = outerRadius;
                 verts->fInnerRadius = innerRadius;
                 verts++;
             }
             // Add the additional vertices for overstroked rrects.
+            // Effectively this is an additional rrect, drawn inside out,
+            // with outerRadius == -innerRadius. This will give us correct AA in the center.
             //
             // Note that args.fInnerRadius is negative in this case.
             // Also, the offset is a constant vector pointing to the right, which guarantees
             // that the distance value along the inner rectangle is constant, which
             // is what we want to get nice anti-aliasing.
             if (kOverstroke_RRectType == fType) {
-                // outerRadius = originalOuter + 0.5, and innerRadius = originalInner - 0.5.
-                // What we want is originalOuter - originalInner + 0.5, so we subtract 0.5.
-                SkScalar inset = outerRadius - args.fInnerRadius - SK_ScalarHalf;
+                verts->fPos = SkPoint::Make(bounds.fLeft + outerRadius, yCoords[1]);
+                verts->fColor = color;
+                verts->fOffset = SkPoint::Make(0, 0);
+                verts->fOuterRadius = -args.fInnerRadius;
+                verts->fInnerRadius = innerRadius;
+                verts++;
+
+                verts->fPos = SkPoint::Make(bounds.fRight - outerRadius, yCoords[1]);
+                verts->fColor = color;
+                verts->fOffset = SkPoint::Make(0, 0);
+                verts->fOuterRadius = -args.fInnerRadius;
+                verts->fInnerRadius = innerRadius;
+                verts++;
+
+                SkScalar inset = outerRadius - args.fInnerRadius;
                 verts->fPos = SkPoint::Make(bounds.fLeft + inset,
                                             bounds.fTop + inset);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(1, 0);
-                verts->fOuterRadius = outerRadius;
+                verts->fOuterRadius = -args.fInnerRadius;

[egdaniel, 2016/08/25 20:24:27]

does this need to be normalized? If so just use -innerRadius?

[jvanverth1, 2016/08/26 14:35:20]

No, the math is a little weird. We pass in normalized coordinates for the
offset, subtract the length of that from 1, and then multiply by whatever's sent
for the outerRadius to put the difference into device space.  So t = radius*(1 -
distance/radius), where distance is in device space, so d/r is the normalized
distance.

That said, it used to be just t = radius - distance, and I'm not sure why I
changed it. I have a note to go back and figure out why I made it more
complicated.

                 verts->fInnerRadius = innerRadius;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fRight - inset,
                                             bounds.fTop + inset);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(1, 0);
-                verts->fOuterRadius = outerRadius;
+                verts->fOuterRadius = -args.fInnerRadius;
                 verts->fInnerRadius = innerRadius;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fLeft + inset,
                                             bounds.fBottom - inset);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(1, 0);
-                verts->fOuterRadius = outerRadius;
+                verts->fOuterRadius = -args.fInnerRadius;
                 verts->fInnerRadius = innerRadius;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fRight - inset,
                                             bounds.fBottom - inset);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(1, 0);
-                verts->fOuterRadius = outerRadius;
+                verts->fOuterRadius = -args.fInnerRadius;
+                verts->fInnerRadius = innerRadius;
+                verts++;
+
+                verts->fPos = SkPoint::Make(bounds.fLeft + outerRadius, yCoords[2]);
+                verts->fColor = color;
+                verts->fOffset = SkPoint::Make(0, 0);
+                verts->fOuterRadius = -args.fInnerRadius;
+                verts->fInnerRadius = innerRadius;
+                verts++;
+
+                verts->fPos = SkPoint::Make(bounds.fRight - outerRadius, yCoords[2]);
+                verts->fColor = color;
+                verts->fOffset = SkPoint::Make(0, 0);
+                verts->fOuterRadius = -args.fInnerRadius;
                 verts->fInnerRadius = innerRadius;
                 verts++;
             }
         }
 
         helper.recordDraw(target, gp);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         RRectCircleRendererBatch* that = t->cast<RRectCircleRendererBatch>();
@@ skipping 428 matching lines @@
 }
 
 DRAW_BATCH_TEST_DEFINE(RRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
     return create_rrect_batch(color, viewMatrix, rrect, GrTest::TestStrokeRec(random));
 }
 
 #endif