Separate out natively-texture image/bmp draws from cached-as-texture image/bmp draws

src/gpu/GrDrawContext.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 "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
@@ skipping 207 matching lines @@
                                              r,
                                              localMatrix);
     }
 }
 
 static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& point) {
     return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
            point.fY >= rect.fTop && point.fY <= rect.fBottom;
 }
 
+static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
+    return viewMatrix.preservesRightAngles();
+}
+
+static bool should_apply_coverage_aa(const GrPaint& paint, GrRenderTarget* rt) {
+    return paint.isAntiAlias() && !rt->isUnifiedMultisampled();
+}
+
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStrokeInfo* strokeInfo) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
@@ skipping 37 matching lines @@
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     this->getDrawTarget()->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
-    bool needAA = paint.isAntiAlias() &&
-                  !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
+    bool needAA = should_apply_coverage_aa(paint, pipelineBuilder.getRenderTarget());
 
     // The fill path can handle rotation but not skew
     // The stroke path needs the rect to remain axis aligned (no rotation or skew)
     // None of our AA draw rect calls can handle perspective yet
-    bool canApplyAA = width >=0 ? viewMatrix.rectStaysRect() : viewMatrix.preservesRightAngles();
+    bool canApplyAA = width >=0 ? viewMatrix.rectStaysRect() :
+                                  view_matrix_ok_for_aa_fill_rect(viewMatrix);
 
     if (needAA && canApplyAA) {
         SkASSERT(!viewMatrix.hasPerspective());
         SkAutoTUnref<GrDrawBatch> batch;
         if (width >= 0) {
             batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, *strokeInfo));
         } else {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
             batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect, devBoundRect));
@@ skipping 24 matching lines @@
                                    const GrPaint& paint,
                                    const SkMatrix& viewMatrix,
                                    const SkRect& rectToDraw,
                                    const SkRect& localRect) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    this->getDrawTarget()->drawNonAARect(pipelineBuilder,
-                                         paint.getColor(),
-                                         viewMatrix,
-                                         rectToDraw,
-                                         localRect);
+    if (should_apply_coverage_aa(paint, fRenderTarget) &&
+        view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
+        SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::CreateWithLocalRect(
+            paint.getColor(), viewMatrix, rectToDraw, localRect));
+        if (batch) {
+            this->drawBatch(&pipelineBuilder, batch);
+        }
+    } else {
+        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
+                                             paint.getColor(),
+                                             viewMatrix,
+                                             rectToDraw,
+                                             localRect);
+    }
 }
 
 void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rectToDraw,
                                             const SkMatrix& localMatrix) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    this->getDrawTarget()->drawNonAARect(pipelineBuilder,
-                                         paint.getColor(),
-                                         viewMatrix,
-                                         rectToDraw,
-                                         localMatrix);
+    if (should_apply_coverage_aa(paint, pipelineBuilder.getRenderTarget()) &&
+        view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
+        SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::Create(
+            paint.getColor(), viewMatrix, localMatrix, rectToDraw));
+        this->drawBatch(&pipelineBuilder, batch);
+    } else {
+        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
+                                             paint.getColor(),
+                                             viewMatrix,
+                                             rectToDraw,
+                                             localMatrix);
+    }
 }
 
 void GrDrawContext::drawVertices(const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
                                  const SkPoint texCoords[],
                                  const GrColor colors[],
@@ skipping 256 matching lines @@
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     if (!strokeInfo.isDashed()) {
-        bool useCoverageAA = paint.isAntiAlias() &&
-                !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
+        bool useCoverageAA = should_apply_coverage_aa(paint, pipelineBuilder.getRenderTarget());
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
             if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
                 SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFillNestedRects(
                     color, viewMatrix, rects));
                 this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
                 return;
@@ skipping 118 matching lines @@
     args.fAntiAlias = useCoverageAA;
     pr->drawPath(args);
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }