Consolidate handling of infinitely thin primitives and aa bloat handing WRT batch bounds

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 554 matching lines @@
         outerRadius += SK_ScalarHalf;
         innerRadius -= SK_ScalarHalf;
 
         fGeoData.emplace_back(Geometry {
             color,
             innerRadius,
             outerRadius,
             SkRect::MakeLTRB(center.fX - outerRadius, center.fY - outerRadius,
                              center.fX + outerRadius, center.fY + outerRadius)
         });
-        this->setBounds(fGeoData.back().fDevBounds);
+        // Use the original radius and stroke radius for the bounds so that it does not include the
+        // AA bloat.
+        radius += halfWidth;
+        this->setBounds({center.fX - radius, center.fY - radius,
+                         center.fX + radius, center.fY + radius},
+                        HasAABloat::kYes, IsZeroArea::kNo);
         fStroked = isStrokeOnly && innerRadius > 0;
     }
 
     const char* name() const override { return "CircleBatch"; }
 
     SkString dumpInfo() const override {
         SkString string;
         for (int i = 0; i < fGeoData.count(); ++i) {
             string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f],"
                            "InnerRad: %.2f, OuterRad: %.2f\n",
@@ skipping 92 matching lines @@
 
         if (this->fStroked != that->fStroked) {
             return false;
         }
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
-        this->joinBounds(that->bounds());
+        this->joinBounds(*that);
         return true;
     }
 
     struct Geometry {
         GrColor fColor;
         SkScalar fInnerRadius;
         SkScalar fOuterRadius;
         SkRect fDevBounds;
     };
 
@@ skipping 71 matching lines @@
         batch->fGeoData.emplace_back(Geometry {
             color,
             xRadius,
             yRadius,
             innerXRadius,
             innerYRadius,
             SkRect::MakeLTRB(center.fX - xRadius, center.fY - yRadius,
                              center.fX + xRadius, center.fY + yRadius)
         });
 
+        batch->setBounds(batch->fGeoData.back().fDevBounds, HasAABloat::kYes, IsZeroArea::kNo);
+
         // Outset bounds to include half-pixel width antialiasing.
         batch->fGeoData[0].fDevBounds.outset(SK_ScalarHalf, SK_ScalarHalf);
 
         batch->fStroked = isStrokeOnly && innerXRadius > 0 && innerYRadius > 0;
         batch->fViewMatrixIfUsingLocalCoords = viewMatrix;
-        batch->setBounds(batch->fGeoData.back().fDevBounds);
         return batch;
     }
 
     const char* name() const override { return "EllipseBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
@@ skipping 91 matching lines @@
 
         if (fStroked != that->fStroked) {
             return false;
         }
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
-        this->joinBounds(that->bounds());
+        this->joinBounds(*that);
         return true;
     }
 
     struct Geometry {
         GrColor fColor;
         SkScalar fXRadius;
         SkScalar fYRadius;
         SkScalar fInnerXRadius;
         SkScalar fInnerYRadius;
         SkRect fDevBounds;
@@ skipping 78 matching lines @@
             xRadius,
             yRadius,
             innerXRadius,
             innerYRadius,
             geoDx,
             geoDy,
             dieStyle,
             SkRect::MakeLTRB(center.fX - xRadius - geoDx, center.fY - yRadius - geoDy,
                              center.fX + xRadius + geoDx, center.fY + yRadius + geoDy)
         });
-        SkRect devBounds = batch->fGeoData.back().fBounds;
-        viewMatrix.mapRect(&devBounds);
-        batch->setBounds(devBounds);
+        batch->setTransformedBounds(batch->fGeoData[0].fBounds, viewMatrix, HasAABloat::kYes,
+                                    IsZeroArea::kNo);
         return batch;
     }
 
     const char* name() const override { return "DIEllipseBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
@@ skipping 76 matching lines @@
         if (this->style() != that->style()) {
             return false;
         }
 
         // TODO rewrite to allow positioning on CPU
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
-        this->joinBounds(that->bounds());
+        this->joinBounds(*that);
         return true;
     }
 
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     DIEllipseStyle style() const { return fGeoData[0].fStyle; }
 
     struct Geometry {
         SkMatrix fViewMatrix;
         GrColor fColor;
         SkScalar fXRadius;
@@ skipping 89 matching lines @@
         }
 
         // The radii are outset for two reasons. First, it allows the shader to simply perform
         // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
         // Second, the outer radius is used to compute the verts of the bounding box that is
         // rendered and the outset ensures the box will cover all partially covered by the rrect
         // corners.
         outerRadius += SK_ScalarHalf;
         innerRadius -= SK_ScalarHalf;
 
-        // Expand the rect so all the pixels will be captured.
+        this->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
+
+        // Expand the rect for aa to generate correct vertices.
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
 
         fGeoData.emplace_back(Geometry { color, innerRadius, outerRadius, bounds });
-        this->setBounds(bounds);
     }
 
     const char* name() const override { return "RRectCircleBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
@@ skipping 97 matching lines @@
 
         if (fStroked != that->fStroked) {
             return false;
         }
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
-        this->joinBounds(that->bounds());
+        this->joinBounds(*that);
         return true;
     }
 
     struct Geometry {
         GrColor  fColor;
         SkScalar fInnerRadius;
         SkScalar fOuterRadius;
         SkRect fDevBounds;
     };
 
@@ skipping 49 matching lines @@
                 innerXRadius = devXRadius - devStrokeWidths.fX;
                 innerYRadius = devYRadius - devStrokeWidths.fY;
                 stroked = (innerXRadius >= 0 && innerYRadius >= 0);
             }
 
             devXRadius += devStrokeWidths.fX;
             devYRadius += devStrokeWidths.fY;
             bounds.outset(devStrokeWidths.fX, devStrokeWidths.fY);
         }
 
-        // Expand the rect so all the pixels will be captured.
-        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
-
         RRectEllipseRendererBatch* batch = new RRectEllipseRendererBatch();
         batch->fStroked = stroked;
         batch->fViewMatrixIfUsingLocalCoords = viewMatrix;
+        batch->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
+        // Expand the rect for aa in order to generate the correct vertices.
+        bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
         batch->fGeoData.emplace_back(
             Geometry {color, devXRadius, devYRadius, innerXRadius, innerYRadius, bounds});
-        batch->setBounds(bounds);
         return batch;
     }
 
     const char* name() const override { return "RRectEllipseRendererBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
@@ skipping 111 matching lines @@
 
         if (fStroked != that->fStroked) {
             return false;
         }
 
         if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
-        this->joinBounds(that->bounds());
+        this->joinBounds(*that);
         return true;
     }
 
     struct Geometry {
         GrColor fColor;
         SkScalar fXRadius;
         SkScalar fYRadius;
         SkScalar fInnerXRadius;
         SkScalar fInnerYRadius;
         SkRect fDevBounds;
@@ skipping 140 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