Add blend optimization helpers and use to convert rect draws to clears.

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrContext.h"
@@ skipping 662 matching lines @@
 }
 
 static bool isIRect(const SkRect& r) {
     return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
            SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              const SkRect& rect,
                              SkScalar strokeWidth,
-                             const SkMatrix* matrix,
-                             SkMatrix* combinedMatrix,
-                             SkRect* devRect,
+                             const SkMatrix& combinedMatrix,
+                             SkRect* devBoundRect,
                              bool* useVertexCoverage) {
     // we use a simple coverage ramp to do aa on axis-aligned rects
     // we check if the rect will be axis-aligned, and the rect won't land on
     // integer coords.
 
     // we are keeping around the "tweak the alpha" trick because
     // it is our only hope for the fixed-pipe implementation.
     // In a shader implementation we can give a separate coverage input
     // TODO: remove this ugliness when we drop the fixed-pipe impl
     *useVertexCoverage = false;
@@ skipping 12 matching lines @@
         return false;
     }
 
     if (0 == strokeWidth && target->willUseHWAALines()) {
         return false;
     }
 
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
     if (strokeWidth >= 0) {
 #endif
-        if (!drawState.getViewMatrix().preservesAxisAlignment()) {
+        if (!combinedMatrix.preservesAxisAlignment()) {
             return false;
         }
 
-        if (NULL != matrix && !matrix->preservesAxisAlignment()) {
-            return false;
-        }
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
     } else {
-        if (!drawState.getViewMatrix().preservesAxisAlignment() &&
-            !drawState.getViewMatrix().preservesRightAngles()) {
-            return false;
-        }
-
-        if (NULL != matrix && !matrix->preservesRightAngles()) {
+        if (!combinedMatrix.preservesRightAngles()) {
             return false;
         }
     }
 #endif
 
-    *combinedMatrix = drawState.getViewMatrix();
-    if (NULL != matrix) {
-        combinedMatrix->preConcat(*matrix);
-
-#if GR_DEBUG
-#if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
-        if (strokeWidth >= 0) {
-#endif
-            GrAssert(combinedMatrix->preservesAxisAlignment());
-#if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
-        } else {
-            GrAssert(combinedMatrix->preservesRightAngles());
-        }
-#endif
-#endif
-    }
-
-    combinedMatrix->mapRect(devRect, rect);
+    combinedMatrix.mapRect(devBoundRect, rect);
 
     if (strokeWidth < 0) {
-        return !isIRect(*devRect);
+        return !isIRect(*devBoundRect);
     } else {
         return true;
     }
 }
 
+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;
+}
+
 void GrContext::drawRect(const GrPaint& paint,
                          const SkRect& rect,
                          SkScalar width,
                          const SkMatrix* matrix) {
     SK_TRACE_EVENT0("GrContext::drawRect");
 
     AutoRestoreEffects are;
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are);
 
-    SkRect devRect;
-    SkMatrix combinedMatrix;
+    SkMatrix combinedMatrix = target->drawState()->getViewMatrix();
+    if (NULL != matrix) {
+        combinedMatrix.preConcat(*matrix);
+    }
+
+    // Check if this is a full RT draw and can be replaced with a clear.
+    SkRect rtRect;
+    target->getDrawState().getRenderTarget()->getBoundsRect(&rtRect);
+    SkRect clipSpaceRTRect = rtRect;
+    bool checkClip = false;
+    if (NULL != this->getClip()) {
+        checkClip = true;
+        clipSpaceRTRect.offset(SkIntToScalar(this->getClip()->fOrigin.fX),
+                               SkIntToScalar(this->getClip()->fOrigin.fY));
+    }
+    // Does the clip contain the entire RT?
+    if (!checkClip || target->getClip()->fClipStack->quickContains(clipSpaceRTRect)) {
+        SkMatrix invM;
+        if (!combinedMatrix.invert(&invM)) {
+            return;
+        }
+        // Does the rect bound the RT?
+        SkPoint srcSpaceRTQuad[4];
+        invM.mapRectToQuad(srcSpaceRTQuad, rtRect);
+        if (rect_contains_inclusive(rect, srcSpaceRTQuad[0]) &&
+            rect_contains_inclusive(rect, srcSpaceRTQuad[1]) &&
+            rect_contains_inclusive(rect, srcSpaceRTQuad[2]) &&
+            rect_contains_inclusive(rect, srcSpaceRTQuad[3])) {
+            // Will it blend?
+            GrColor clearColor;
+            if (paint.isOpaqueAndConstantColor(&clearColor)) {
+                target->clear(NULL, clearColor);
+                return;
+            }
+        }
+    }
+
+    SkRect devBoundRect;
     bool useVertexCoverage;
     bool needAA = paint.isAntiAlias() &&
                   !target->getDrawState().getRenderTarget()->isMultisampled();
-    bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
-                                           &combinedMatrix, &devRect,
+    bool doAA = needAA && apply_aa_to_rect(target, rect, width, combinedMatrix, &devBoundRect,
                                            &useVertexCoverage);
     if (doAA) {
         GrDrawState::AutoViewMatrixRestore avmr;
         if (!avmr.setIdentity(target->drawState())) {
             return;
         }
         if (width >= 0) {
             fAARectRenderer->strokeAARect(this->getGpu(), target,
-                                          rect, combinedMatrix, devRect,
+                                          rect, combinedMatrix, devBoundRect,
                                           width, useVertexCoverage);
         } else {
             // filled AA rect
             fAARectRenderer->fillAARect(this->getGpu(), target,
-                                        rect, combinedMatrix, devRect,
+                                        rect, combinedMatrix, devBoundRect,
                                         useVertexCoverage);
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
@@ skipping 901 matching lines @@
         return NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif