Revert of Fix for degenerate stroke rect

src/gpu/batches/GrAAStrokeRectBatch.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 "GrAAStrokeRectBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 35 matching lines @@
 class AAStrokeRectBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // TODO support AA rotated stroke rects by copying around view matrices
     struct Geometry {
         SkRect fDevOutside;
         SkRect fDevOutsideAssist;
         SkRect fDevInside;
         GrColor fColor;
-        bool fDegenerate;
     };
 
     static AAStrokeRectBatch* Create(const SkMatrix& viewMatrix, bool miterStroke) {
         return new AAStrokeRectBatch(viewMatrix, miterStroke);
     }
 
     const char* name() const override { return "AAStrokeRect"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     bool canAppend(const SkMatrix& viewMatrix, bool miterStroke) {
         return fViewMatrix.cheapEqualTo(viewMatrix) && fMiterStroke == miterStroke;
     }
 
     void append(GrColor color, const SkRect& devOutside, const SkRect& devOutsideAssist,
-                const SkRect& devInside, bool degenerate) {
+                const SkRect& devInside) {
         Geometry& geometry = fGeoData.push_back();
         geometry.fColor = color;
         geometry.fDevOutside = devOutside;
         geometry.fDevOutsideAssist = devOutsideAssist;
         geometry.fDevInside = devInside;
-        geometry.fDegenerate = degenerate;
     }
 
     void appendAndUpdateBounds(GrColor color, const SkRect& devOutside,
-                               const SkRect& devOutsideAssist, const SkRect& devInside,
-                               bool degenerate) {
-        this->append(color, devOutside, devOutsideAssist, devInside, degenerate);
+                               const SkRect& devOutsideAssist, const SkRect& devInside) {
+        this->append(color, devOutside, devOutsideAssist, devInside);
 
         SkRect bounds;
         this->updateBounds(&bounds, fGeoData.back());
         this->joinBounds(bounds);
     }
 
     void init() { this->updateBounds(&fBounds, fGeoData[0]); }
 
 private:
     void updateBounds(SkRect* bounds, const Geometry& geo) {
@@ skipping 37 matching lines @@
     void generateAAStrokeRectGeometry(void* vertices,
                                       size_t offset,
                                       size_t vertexStride,
                                       int outerVertexNum,
                                       int innerVertexNum,
                                       GrColor color,
                                       const SkRect& devOutside,
                                       const SkRect& devOutsideAssist,
                                       const SkRect& devInside,
                                       bool miterStroke,
-                                      bool degenerate,
                                       bool tweakAlphaForCoverage) const;
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fCanTweakAlphaForCoverage;
     };
 
@@ skipping 61 matching lines @@
         this->generateAAStrokeRectGeometry(vertices,
                                            i * verticesPerInstance * vertexStride,
                                            vertexStride,
                                            outerVertexNum,
                                            innerVertexNum,
                                            args.fColor,
                                            args.fDevOutside,
                                            args.fDevOutsideAssist,
                                            args.fDevInside,
                                            fMiterStroke,
-                                           args.fDegenerate,
                                            canTweakAlphaForCoverage);
     }
     helper.recordDraw(target);
 }
 
 const GrIndexBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
                                                        bool miterStroke) {
 
     if (miterStroke) {
         static const uint16_t gMiterIndices[] = {
@@ skipping 110 matching lines @@
     }
 
     if (this->color() != that->color()) {
         fBatch.fColor = GrColor_ILLEGAL;
     }
     fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
     this->joinBounds(that->bounds());
     return true;
 }
 
-static void setup_scale(int* scale, SkScalar inset) {
-    if (inset < SK_ScalarHalf) {
-        *scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
-        SkASSERT(*scale >= 0 && *scale <= 255);
-    } else {
-        *scale = 0xff;
-    }
-}
-
 void AAStrokeRectBatch::generateAAStrokeRectGeometry(void* vertices,
                                                      size_t offset,
                                                      size_t vertexStride,
                                                      int outerVertexNum,
                                                      int innerVertexNum,
                                                      GrColor color,
                                                      const SkRect& devOutside,
                                                      const SkRect& devOutsideAssist,
                                                      const SkRect& devInside,
                                                      bool miterStroke,
-                                                     bool degenerate,
                                                      bool tweakAlphaForCoverage) const {
     intptr_t verts = reinterpret_cast<intptr_t>(vertices) + offset;
 
     // We create vertices for four nested rectangles. There are two ramps from 0 to full
     // coverage, one on the exterior of the stroke and the other on the interior.
     // The following pointers refer to the four rects, from outermost to innermost.
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + outerVertexNum * vertexStride);
     SkPoint* fan2Pos = reinterpret_cast<SkPoint*>(verts + 2 * outerVertexNum * vertexStride);
     SkPoint* fan3Pos = reinterpret_cast<SkPoint*>(verts +
                                                   (2 * outerVertexNum + innerVertexNum) *
                                                   vertexStride);
 
 #ifndef SK_IGNORE_THIN_STROKED_RECT_FIX
     // TODO: this only really works if the X & Y margins are the same all around
     // the rect (or if they are all >= 1.0).
-    SkScalar inset;
-    if (!degenerate) {
-        inset = SkMinScalar(SK_Scalar1, devOutside.fRight - devInside.fRight);
-        inset = SkMinScalar(inset, devInside.fLeft - devOutside.fLeft);
-        inset = SkMinScalar(inset, devInside.fTop - devOutside.fTop);
-        if (miterStroke) {
-            inset = SK_ScalarHalf * SkMinScalar(inset, devOutside.fBottom - devInside.fBottom);
-        } else {
-            inset = SK_ScalarHalf * SkMinScalar(inset, devOutsideAssist.fBottom -
-                                                       devInside.fBottom);
-        }
-        SkASSERT(inset >= 0);
+    SkScalar inset = SkMinScalar(SK_Scalar1, devOutside.fRight - devInside.fRight);
+    inset = SkMinScalar(inset, devInside.fLeft - devOutside.fLeft);
+    inset = SkMinScalar(inset, devInside.fTop - devOutside.fTop);
+    if (miterStroke) {
+        inset = SK_ScalarHalf * SkMinScalar(inset, devOutside.fBottom - devInside.fBottom);
     } else {
-        // TODO use real devRect here
-        inset = SkMinScalar(devOutside.width(), SK_Scalar1);
-        inset = SK_ScalarHalf * SkMinScalar(inset, SkTMax(devOutside.height(),
-                                                          devOutsideAssist.height()));
+        inset = SK_ScalarHalf * SkMinScalar(inset, devOutsideAssist.fBottom -
+                                                   devInside.fBottom);
     }
+    SkASSERT(inset >= 0);
 #else
-    SkScalar inset;
-    if (!degenerate) {
-        inset = SK_ScalarHalf;
-    } else {
-        // TODO use real devRect here
-        inset = SkMinScalar(devOutside.width(), SK_Scalar1);
-        inset = SK_ScalarHalf * SkMinScalar(inset, SkTMax(devOutside.height(),
-                                                          devOutsideAssist.height()));
-    }
+    SkScalar inset = SK_ScalarHalf;
 #endif
 
     if (miterStroke) {
         // outermost
         set_inset_fan(fan0Pos, vertexStride, devOutside, -SK_ScalarHalf, -SK_ScalarHalf);
         // inner two
         set_inset_fan(fan1Pos, vertexStride, devOutside,  inset,  inset);
-        if (!degenerate) {
-            set_inset_fan(fan2Pos, vertexStride, devInside,  -inset, -inset);
-            // innermost
-            set_inset_fan(fan3Pos, vertexStride, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
-        } else {
-            // When the interior rect has become degenerate we smoosh to a single point
-            SkASSERT(devInside.fLeft == devInside.fRight &&
-                     devInside.fTop == devInside.fBottom);
-            fan2Pos->setRectFan(devInside.fLeft, devInside.fTop,
-                                devInside.fRight, devInside.fBottom, vertexStride);
-            fan3Pos->setRectFan(devInside.fLeft, devInside.fTop,
-                                devInside.fRight, devInside.fBottom, vertexStride);
-        }
+        set_inset_fan(fan2Pos, vertexStride, devInside,  -inset, -inset);
+        // innermost
+        set_inset_fan(fan3Pos, vertexStride, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     } else {
         SkPoint* fan0AssistPos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride);
         SkPoint* fan1AssistPos = reinterpret_cast<SkPoint*>(verts +
                                                             (outerVertexNum + 4) *
                                                             vertexStride);
         // outermost
         set_inset_fan(fan0Pos, vertexStride, devOutside, -SK_ScalarHalf, -SK_ScalarHalf);
         set_inset_fan(fan0AssistPos, vertexStride, devOutsideAssist, -SK_ScalarHalf,
                       -SK_ScalarHalf);
         // outer one of the inner two
         set_inset_fan(fan1Pos, vertexStride, devOutside,  inset,  inset);
         set_inset_fan(fan1AssistPos, vertexStride, devOutsideAssist,  inset,  inset);
-        if (!degenerate) {
-            // inner one of the inner two
-            set_inset_fan(fan2Pos, vertexStride, devInside,  -inset, -inset);
-            // innermost
-            set_inset_fan(fan3Pos, vertexStride, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
-        } else {
-            // When the interior rect has become degenerate we smoosh to a single point
-            SkASSERT(devInside.fLeft == devInside.fRight &&
-                     devInside.fTop == devInside.fBottom);
-            fan2Pos->setRectFan(devInside.fLeft, devInside.fTop,
-                                devInside.fRight, devInside.fBottom, vertexStride);
-            fan3Pos->setRectFan(devInside.fLeft, devInside.fTop,
-                                devInside.fRight, devInside.fBottom, vertexStride);
-        }
+        // inner one of the inner two
+        set_inset_fan(fan2Pos, vertexStride, devInside,  -inset, -inset);
+        // innermost
+        set_inset_fan(fan3Pos, vertexStride, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     }
 
     // Make verts point to vertex color and then set all the color and coverage vertex attrs
     // values. The outermost rect has 0 coverage
     verts += sizeof(SkPoint);
     for (int i = 0; i < outerVertexNum; ++i) {
         if (tweakAlphaForCoverage) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
             *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
         }
     }
 
     // scale is the coverage for the the inner two rects.
     int scale;
-    setup_scale(&scale, inset);
+    if (inset < SK_ScalarHalf) {
+        scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
+        SkASSERT(scale >= 0 && scale <= 255);
+    } else {
+        scale = 0xff;
+    }
 
     float innerCoverage = GrNormalizeByteToFloat(scale);
     GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
 
     verts += outerVertexNum * vertexStride;
     for (int i = 0; i < outerVertexNum + innerVertexNum; ++i) {
         if (tweakAlphaForCoverage) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
-            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = innerCoverage;
+            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) =
+                    innerCoverage;
         }
     }
 
-    // The innermost rect has 0 coverage, unless we are degenerate, in which case we must apply the
-    // scaled coverage
+    // The innermost rect has 0 coverage
     verts += (outerVertexNum + innerVertexNum) * vertexStride;
-    if (!degenerate) {
-        innerCoverage = 0;
-        scaledColor = 0;
-    }
-
     for (int i = 0; i < innerVertexNum; ++i) {
         if (tweakAlphaForCoverage) {
-            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
-            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = innerCoverage;
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
         }
     }
 }
 
 namespace GrAAStrokeRectBatch {
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& devOutside,
                     const SkRect& devOutsideAssist,
                     const SkRect& devInside,
-                    bool miterStroke,
-                    bool degenerate) {
+                    bool miterStroke) {
     AAStrokeRectBatch* batch = AAStrokeRectBatch::Create(viewMatrix, miterStroke);
-    batch->append(color, devOutside, devOutsideAssist, devInside, degenerate);
+    batch->append(color, devOutside, devOutsideAssist, devInside);
     batch->init();
     return batch;
 }
 
 bool Append(GrBatch* origBatch,
             GrColor color,
             const SkMatrix& viewMatrix,
             const SkRect& devOutside,
             const SkRect& devOutsideAssist,
             const SkRect& devInside,
-            bool miterStroke,
-            bool degenerate) {
+            bool miterStroke) {
     AAStrokeRectBatch* batch = origBatch->cast<AAStrokeRectBatch>();
 
     // we can't batch across vm changes
     if (!batch->canAppend(viewMatrix, miterStroke)) {
         return false;
     }
 
-    batch->appendAndUpdateBounds(color, devOutside, devOutsideAssist, devInside, degenerate);
+    batch->appendAndUpdateBounds(color, devOutside, devOutsideAssist, devInside);
     return true;
 }
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 #include "GrBatchTest.h"
 
 DRAW_BATCH_TEST_DEFINE(AAStrokeRectBatch) {
     bool miterStroke = random->nextBool();
-    bool degenerate = random->nextBool();
 
     // Create mock stroke rect
     SkRect outside = GrTest::TestRect(random);
     SkScalar minDim = SkMinScalar(outside.width(), outside.height());
     SkScalar strokeWidth = minDim * 0.1f;
     SkRect outsideAssist = outside;
     outsideAssist.outset(strokeWidth, strokeWidth);
     SkRect inside = outside;
     inside.inset(strokeWidth, strokeWidth);
 
     GrColor color = GrRandomColor(random);
 
     return GrAAStrokeRectBatch::Create(color, GrTest::TestMatrix(random), outside, outsideAssist,
-                                       inside, degenerate, miterStroke);
+                                       inside, miterStroke);
 }
 
 #endif