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

src/gpu/instanced/InstancedRendering.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstancedRendering.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 105 matching lines @@
     }
 
     Batch* batch = this->createBatch();
     batch->fInfo.fAntialiasMode = antialiasMode;
     batch->fInfo.fShapeTypes = GetShapeFlag(type);
     batch->fInfo.fCannotDiscard = !info.fCanDiscard;
 
     Instance& instance = batch->getSingleInstance();
     instance.fInfo = (int)type << kShapeType_InfoBit;
 
+    Batch::HasAABloat aaBloat = (antialiasMode == AntialiasMode::kCoverage)
+                                ? Batch::HasAABloat::kYes
+                                : Batch::HasAABloat::kNo;
+    Batch::IsZeroArea zeroArea = (bounds.isEmpty()) ? Batch::IsZeroArea::kYes
+                                                    : Batch::IsZeroArea::kNo;
+
     // The instanced shape renderer draws rectangles of [-1, -1, +1, +1], so we find the matrix that
     // will map this rectangle to the same device coordinates as "viewMatrix * bounds".
     float sx = 0.5f * bounds.width();
     float sy = 0.5f * bounds.height();
     float tx = sx + bounds.fLeft;
     float ty = sy + bounds.fTop;
     if (!viewMatrix.hasPerspective()) {
         float* m = instance.fShapeMatrix2x3;
         m[0] = viewMatrix.getScaleX() * sx;
         m[1] = viewMatrix.getSkewX() * sy;
         m[2] = viewMatrix.getTranslateX() +
                viewMatrix.getScaleX() * tx + viewMatrix.getSkewX() * ty;
 
         m[3] = viewMatrix.getSkewY() * sx;
         m[4] = viewMatrix.getScaleY() * sy;
         m[5] = viewMatrix.getTranslateY() +
                viewMatrix.getSkewY() * tx + viewMatrix.getScaleY() * ty;
 
         // Since 'm' is a 2x3 matrix that maps the rect [-1, +1] into the shape's device-space quad,
         // it's quite simple to find the bounding rectangle:
         float devBoundsHalfWidth = fabsf(m[0]) + fabsf(m[1]);
         float devBoundsHalfHeight = fabsf(m[3]) + fabsf(m[4]);
-        batch->fBounds.fLeft = m[2] - devBoundsHalfWidth;
-        batch->fBounds.fRight = m[2] + devBoundsHalfWidth;
-        batch->fBounds.fTop = m[5] - devBoundsHalfHeight;
-        batch->fBounds.fBottom = m[5] + devBoundsHalfHeight;
+        SkRect batchBounds;
+        batchBounds.fLeft = m[2] - devBoundsHalfWidth;
+        batchBounds.fRight = m[2] + devBoundsHalfWidth;
+        batchBounds.fTop = m[5] - devBoundsHalfHeight;
+        batchBounds.fBottom = m[5] + devBoundsHalfHeight;
+        batch->setBounds(batchBounds, aaBloat, zeroArea);
 
         // TODO: Is this worth the CPU overhead?
         batch->fInfo.fNonSquare =
             fabsf(devBoundsHalfHeight - devBoundsHalfWidth) > 0.5f || // Early out.
             fabs(m[0] * m[3] + m[1] * m[4]) > 1e-3f || // Skew?
             fabs(m[0] * m[0] + m[1] * m[1] - m[3] * m[3] - m[4] * m[4]) > 1e-2f; // Diff. lengths?
     } else {
         SkMatrix shapeMatrix(viewMatrix);
         shapeMatrix.preTranslate(tx, ty);
         shapeMatrix.preScale(sx, sy);
         instance.fInfo |= kPerspective_InfoFlag;
 
         float* m = instance.fShapeMatrix2x3;
         m[0] = SkScalarToFloat(shapeMatrix.getScaleX());
         m[1] = SkScalarToFloat(shapeMatrix.getSkewX());
         m[2] = SkScalarToFloat(shapeMatrix.getTranslateX());
         m[3] = SkScalarToFloat(shapeMatrix.getSkewY());
         m[4] = SkScalarToFloat(shapeMatrix.getScaleY());
         m[5] = SkScalarToFloat(shapeMatrix.getTranslateY());
 
         // Send the perspective column as a param.
         batch->appendParamsTexel(shapeMatrix[SkMatrix::kMPersp0], shapeMatrix[SkMatrix::kMPersp1],
                                  shapeMatrix[SkMatrix::kMPersp2]);
         batch->fInfo.fHasPerspective = true;
 
-        viewMatrix.mapRect(&batch->fBounds, bounds);
-
+        batch->setBounds(bounds, aaBloat, zeroArea);
         batch->fInfo.fNonSquare = true;
     }
 
     instance.fColor = color;
 
     const float* rectAsFloats = localRect.asScalars(); // Ensure SkScalar == float.
     memcpy(&instance.fLocalRect, rectAsFloats, 4 * sizeof(float));
 
-    batch->fPixelLoad = batch->fBounds.height() * batch->fBounds.width();
+    batch->fPixelLoad = batch->bounds().height() * batch->bounds().width();
     return batch;
 }
 
 inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
                                                     const GrInstancedPipelineInfo& info,
                                                     bool* useHWAA, AntialiasMode* antialiasMode) {
     SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil);
     SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled);
 
     if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) {
@@ skipping 147 matching lines @@
 
 void InstancedRendering::Batch::initBatchTracker(const GrXPOverridesForBatch& overrides) {
     Draw& draw = this->getSingleDraw(); // This will assert if we have > 1 command.
     SkASSERT(draw.fGeometry.isEmpty());
     SkASSERT(SkIsPow2(fInfo.fShapeTypes));
     SkASSERT(!fIsTracked);
 
     if (kRect_ShapeFlag == fInfo.fShapeTypes) {
         draw.fGeometry = InstanceProcessor::GetIndexRangeForRect(fInfo.fAntialiasMode);
     } else if (kOval_ShapeFlag == fInfo.fShapeTypes) {
-        draw.fGeometry = InstanceProcessor::GetIndexRangeForOval(fInfo.fAntialiasMode, fBounds);
+        draw.fGeometry = InstanceProcessor::GetIndexRangeForOval(fInfo.fAntialiasMode,
+                                                                 this->bounds());
     } else {
         draw.fGeometry = InstanceProcessor::GetIndexRangeForRRect(fInfo.fAntialiasMode);
     }
 
     if (!fParams.empty()) {
         SkASSERT(fInstancedRendering->fParams.count() < (int)kParamsIdx_InfoMask); // TODO: cleaner.
         this->getSingleInstance().fInfo |= fInstancedRendering->fParams.count();
         fInstancedRendering->fParams.push_back_n(fParams.count(), fParams.begin());
     }
 
@@ skipping 28 matching lines @@
         // is that the itty bitty rects combine with other shapes and the giant ones don't.
         constexpr SkScalar kMaxPixelsToGeneralizeRects = 256 * 256;
         if (fInfo.isSimpleRects() && fPixelLoad > kMaxPixelsToGeneralizeRects) {
             return false;
         }
         if (that->fInfo.isSimpleRects() && that->fPixelLoad > kMaxPixelsToGeneralizeRects) {
             return false;
         }
     }
 
-    fBounds.join(that->fBounds);
+    this->joinBounds(*that);
     fInfo = combinedInfo;
     fPixelLoad += that->fPixelLoad;
 
     // Adopt the other batch's draws.
     fNumDraws += that->fNumDraws;
     fNumChangesInGeometry += that->fNumChangesInGeometry;
     if (fTailDraw->fGeometry != that->fHeadDraw->fGeometry) {
         ++fNumChangesInGeometry;
     }
     fTailDraw->fNext = that->fHeadDraw;
@@ skipping 64 matching lines @@
 }
 
 void InstancedRendering::resetGpuResources(ResetType resetType) {
     fVertexBuffer.reset();
     fIndexBuffer.reset();
     fParamsBuffer.reset();
     this->onResetGpuResources(resetType);
 }
 
 }