First pass at Rect Effect

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 668 matching lines @@
     return SkScalarIsInt(r.fLeft) && SkScalarIsInt(r.fTop) &&
            SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              const GrRect& rect,
                              SkScalar width,
                              const SkMatrix* matrix,
                              SkMatrix* combinedMatrix,
                              GrRect* devRect,
-                             bool* useVertexCoverage) {
+                             bool* useVertexCoverage,
+                             bool stroked) {

[bsalomon, 2013/04/08 15:48:39]

I think the width param already tells you if its stroked (-1 is fill and
otherwise its the stroke width IIRC). Maybe rename to strokeWidth?

[robertphillips, 2013/04/08 19:33:20]

Done.

     // 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;
     if (!target->getDrawState().canTweakAlphaForCoverage()) {
         if (disable_coverage_aa_for_blend(target)) {
 #if GR_DEBUG
             //GrPrintf("Turning off AA to correctly apply blend.\n");
 #endif
             return false;
         } else {
             *useVertexCoverage = true;
         }
     }
     const GrDrawState& drawState = target->getDrawState();
     if (drawState.getRenderTarget()->isMultisampled()) {
         return false;
     }
 
     if (0 == width && target->willUseHWAALines()) {
         return false;
     }
 
-    if (!drawState.getViewMatrix().preservesAxisAlignment()) {
-        return false;
+#ifdef SHADER_AA_FILL_RECT
+    if (stroked) {
+#endif
+        if (!drawState.getViewMatrix().preservesAxisAlignment()) {
+            return false;
+        }
+
+        if (NULL != matrix && !matrix->preservesAxisAlignment()) {
+            return false;
+        }
+#ifdef SHADER_AA_FILL_RECT
+    } else {
+        if (!drawState.getViewMatrix().preservesAxisAlignment() &&
+            !drawState.getViewMatrix().notSkewOrPersp()) {
+            return false;
+        }
+
+        if (NULL != matrix && !matrix->notSkewOrPersp()) {
+            return false;
+        }
     }
-
-    if (NULL != matrix &&
-        !matrix->preservesAxisAlignment()) {
-        return false;
-    }
+#endif
 
     *combinedMatrix = drawState.getViewMatrix();
     if (NULL != matrix) {
         combinedMatrix->preConcat(*matrix);
-        GrAssert(combinedMatrix->preservesAxisAlignment());
+
+#if GR_DEBUG
+#ifdef SHADER_AA_FILL_RECT
+        if (stroked) {
+#endif
+            GrAssert(combinedMatrix->preservesAxisAlignment());
+#ifdef SHADER_AA_FILL_RECT
+        } else {
+            GrAssert(combinedMatrix->notSkewOrPersp());
+        }
+#endif
+#endif
     }
 
     combinedMatrix->mapRect(devRect, rect);
     devRect->sort();
 
     if (width < 0) {
         return !isIRect(*devRect);
     } else {
         return true;
     }
 }
 
 void GrContext::drawRect(const GrPaint& paint,
                          const GrRect& rect,
                          SkScalar width,
                          const SkMatrix* matrix) {
     SK_TRACE_EVENT0("GrContext::drawRect");
 
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW);
     GrDrawState::AutoStageDisable atr(fDrawState);
 
     GrRect devRect = rect;
     SkMatrix combinedMatrix;
     bool useVertexCoverage;
     bool needAA = paint.isAntiAlias() &&
                   !this->getRenderTarget()->isMultisampled();
     bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
                                            &combinedMatrix, &devRect,
-                                           &useVertexCoverage);
+                                           &useVertexCoverage,
+                                           width >= 0);
 
     if (doAA) {
         GrDrawState::AutoDeviceCoordDraw adcd(target->drawState());
         if (!adcd.succeeded()) {
             return;
         }
         if (width >= 0) {
             GrVec strokeSize;
             if (width > 0) {
                 strokeSize.set(width, width);
                 combinedMatrix.mapVectors(&strokeSize, 1);
                 strokeSize.setAbs(strokeSize);
             } else {
                 strokeSize.set(SK_Scalar1, SK_Scalar1);
             }
             fAARectRenderer->strokeAARect(this->getGpu(), target, devRect,
-                                         strokeSize, useVertexCoverage);
+                                          strokeSize, useVertexCoverage);
         } else {
+            // filled AA rect
+#ifdef SHADER_AA_FILL_RECT
+            fAARectRenderer->shaderFillAARect(this->getGpu(), target,
+                                              rect, combinedMatrix, devRect,
+                                              useVertexCoverage);
+#else
             fAARectRenderer->fillAARect(this->getGpu(), target,
-                                       devRect, useVertexCoverage);
+                                        devRect, useVertexCoverage);
+#endif
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
         static const int worstCaseVertCount = 10;
@@ skipping 25 matching lines @@
         }
 
         GrDrawState::AutoViewMatrixRestore avmr;
         if (NULL != matrix) {
             GrDrawState* drawState = target->drawState();
             avmr.set(drawState, *matrix);
         }
 
         target->drawNonIndexed(primType, 0, vertCount);
     } else {
+        // filled BW rect
 #if GR_STATIC_RECT_VB
             const GrVertexBuffer* sqVB = fGpu->getUnitSquareVertexBuffer();
             if (NULL == sqVB) {
                 GrPrintf("Failed to create static rect vb.\n");
                 return;
             }
 
             GrDrawState* drawState = target->drawState();
             target->drawState()->setDefaultVertexAttribs();
             target->setVertexSourceToBuffer(sqVB);
@@ skipping 964 matching lines @@
         return srcTexture;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif