Do not apply hairline optimization for paths if nv_path_rendering is used

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"
 
 #include "effects/GrSingleTextureEffect.h"
 #include "effects/GrConfigConversionEffect.h"
 
 #include "GrAARectRenderer.h"
 #include "GrBufferAllocPool.h"
 #include "GrGpu.h"
 #include "GrDrawTargetCaps.h"
 #include "GrIndexBuffer.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
 #include "GrResourceCache.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrStencilBuffer.h"
 #include "GrTextStrike.h"
+#include "SkDrawProcs.h"
 #include "SkRTConf.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTrace.h"
 
 SK_DEFINE_INST_COUNT(GrContext)
 SK_DEFINE_INST_COUNT(GrDrawState)
 
@@ skipping 992 matching lines @@
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
     bool useAA = paint.isAntiAlias() &&
                  !target->getDrawState().getRenderTarget()->isMultisampled() &&
                  !disable_coverage_aa_for_blend(target);
 
     if (!fOvalRenderer->drawSimpleRRect(target, this, useAA, rect, stroke)) {
         SkPath path;
         path.addRRect(rect);
-        this->internalDrawPath(target, useAA, path, stroke);
+        this->internalDrawPath(target, paint, useAA, path, stroke);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(const GrPaint& paint,
                          const SkRect& oval,
                          const SkStrokeRec& stroke) {
     if (oval.isEmpty()) {
        return;
     }
 
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
     bool useAA = paint.isAntiAlias() &&
                  !target->getDrawState().getRenderTarget()->isMultisampled() &&
                  !disable_coverage_aa_for_blend(target);
 
     if (!fOvalRenderer->drawOval(target, this, useAA, oval, stroke)) {
         SkPath path;
         path.addOval(oval);
-        this->internalDrawPath(target, useAA, path, stroke);
+        this->internalDrawPath(target, paint, useAA, path, stroke);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             const SkPath& path,
                             const SkStrokeRec& stroke,
                             SkRect rects[2],
                             bool* useVertexCoverage) {
     SkASSERT(stroke.isFillStyle());
@@ skipping 55 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.
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
+    GrDrawState* drawState = target->drawState();
 
-    bool useAA = paint.isAntiAlias() && !target->getDrawState().getRenderTarget()->isMultisampled();
+    bool useAA = paint.isAntiAlias() && !drawState->getRenderTarget()->isMultisampled();
+
     if (useAA && stroke.getWidth() < 0 && !path.isConvex()) {
         // Concave AA paths are expensive - try to avoid them for special cases
         bool useVertexCoverage;
         SkRect rects[2];
 
         if (is_nested_rects(target, path, stroke, rects, &useVertexCoverage)) {
-            SkMatrix origViewMatrix = target->getDrawState().getViewMatrix();
+            SkMatrix origViewMatrix = drawState->getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (!avmr.setIdentity(target->drawState())) {
                 return;
             }
 
             fAARectRenderer->fillAANestedRects(this->getGpu(), target,
                                                rects,
                                                origViewMatrix,
                                                useVertexCoverage);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType()
         || !fOvalRenderer->drawOval(target, this, useAA, ovalRect, stroke)) {
-        this->internalDrawPath(target, useAA, path, stroke);
+        this->internalDrawPath(target, paint, useAA, path, stroke);
     }
 }
 
-void GrContext::internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
-                                 const SkStrokeRec& stroke) {
+namespace {
+// See also: SkDrawTreatAsHairline.
+static inline bool should_convert_to_hairline(const GrPaint& paint, const SkStrokeRec& stroke,
+                                              const SkMatrix& matrix, SkScalar* coverage) {
+
+    if (stroke.getStyle() != SkStrokeRec::kStroke_Style) {
+        return false;
+    }
+
+    SkASSERT(0 != stroke.getWidth());
+
+    if (!paint.isAntiAlias()) {

[bsalomon, 2013/10/30 14:37:39]

Currently GrContext tries to convert the GrPaint to a GrDrawState early and then
forget about the GrPaint. It looks like there are two reasons for passing the
paint down to internalDrawPath in this CL.

1) To get this anti-alias flag. Currently we cannot just use the "useAA" param
to internalDrawPath(). The useAA param really means "do shader based-aa" and we
have this logic replicated in a handful places:

    bool useAA = paint.isAntiAlias() &&
                 !target->getDrawState().getRenderTarget()->isMultisampled() &&
                 !disable_coverage_aa_for_blend(target);

I think we should just pass paint.isAntiAlias() to internal draw path and have
that function do this logic.

Some of the callers need to do it anyway because they also pass useAA to helper
classes. I'm happy to go back later and make GrOvalRenderer, GrAARectRenderer,
etc take paint.isAntiAlias() rather than require their callers to do the tests
above.

2) To get the coverage. But that is already copied to GrDrawState.

[Kimmo Kinnunen, 2013/11/01 14:56:19]

Done.

+        return false;
+    }
+
+    return SkDrawTreatAAStrokeAsHairline(stroke.getWidth(), matrix, coverage);
+}
+}
+
+
+void GrContext::internalDrawPath(GrDrawTarget* target, const GrPaint& paint, bool useAA,
+                                 const SkPath& path, const SkStrokeRec& origStroke) {
     SkASSERT(!path.isEmpty());
 
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     if (disable_coverage_aa_for_blend(target)) {
 #ifdef SK_DEBUG
         //GrPrintf("Turning off AA to correctly apply blend.\n");
 #endif
         useAA = false;
     }
 
+    SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
+    // Can we treat a thin stroke as a hairline w/ coverage? If we can, we draw lots faster (raster
+    // device does this same test).
+
+    // Do not do this if gpu supports path rendering natively and we might be using the support (useAA ==
+    // false). Hairline renderer is likely to be slow due to program switches.
+    if (useAA || !fGpu->caps()->pathRenderingSupport()) {
+        SkScalar hairlineCoverage;
+        if (should_convert_to_hairline(paint, *stroke, this->getMatrix(), &hairlineCoverage)) {
+            target->drawState()->setCoverage(SkScalarRoundToInt(hairlineCoverage * paint.getCoverage()));
+            stroke.writable()->setHairlineStyle();
+        }
+    }
+
     GrPathRendererChain::DrawType type = useAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                                  GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkPath tmpPath;
-    SkStrokeRec strokeRec(stroke);
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
-    GrPathRenderer* pr = this->getPathRenderer(*pathPtr, strokeRec, target, false, type);
+    GrPathRenderer* pr = this->getPathRenderer(*pathPtr, *stroke, target, false, type);
 
     if (NULL == pr) {
-        if (!strokeRec.isHairlineStyle()) {
+        if (!stroke->isHairlineStyle()) {
             // It didn't work the 1st time, so try again with the stroked path
-            if (strokeRec.applyToPath(&tmpPath, *pathPtr)) {
+            if (stroke->applyToPath(&tmpPath, *pathPtr)) {
                 pathPtr = &tmpPath;
-                strokeRec.setFillStyle();
+                stroke.writable()->setFillStyle();
             }
         }
         if (pathPtr->isEmpty()) {
             return;
         }
 
         // This time, allow SW renderer
-        pr = this->getPathRenderer(*pathPtr, strokeRec, target, true, type);
+        pr = this->getPathRenderer(*pathPtr, *stroke, target, true, type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
         GrPrintf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
-    pr->drawPath(*pathPtr, strokeRec, target, useAA);
+    pr->drawPath(*pathPtr, *stroke, target, useAA);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
     if (NULL == fDrawBuffer) {
         return;
     }
 
     if (kDiscard_FlushBit & flagsBitfield) {
@@ skipping 579 matching lines @@
         return NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif