Implement path cover with nv_path_rendering

src/gpu/GrStencilAndCoverPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrStencilAndCoverPathRenderer.h"
@@ skipping 22 matching lines @@
 GrStencilAndCoverPathRenderer::~GrStencilAndCoverPathRenderer() {
     fGpu->unref();
 }
 
 bool GrStencilAndCoverPathRenderer::canDrawPath(const SkPath& path,
                                                 const SkStrokeRec& stroke,
                                                 const GrDrawTarget* target,
                                                 bool antiAlias) const {
     return stroke.isFillStyle() &&
            !antiAlias && // doesn't do per-path AA, relies on the target having MSAA
+           !target->getDrawState().willEffectReadDstColor() && // not supported yet

[Chris Dalton, 2013/09/13 19:49:58]

I don't think we need this constraint anymore. With the vertexless shaders
everything should "just work".

[bsalomon, 2013/09/13 20:25:28]

Really? I think onDrawPath will have to handle this.

Of course we should also add support for advanced blending.. though there may
still be effects that require dst access so it's not a replacement for adding
support for willEffectReadDstColor().

[Kimmo Kinnunen, 2013/09/18 07:52:38]

I don't think there's code for this yet.. Left as is for now.

            target->getDrawState().getStencil().isDisabled();
 }
 
 GrPathRenderer::StencilSupport GrStencilAndCoverPathRenderer::onGetStencilSupport(
                                                         const SkPath&,
                                                         const SkStrokeRec& ,
                                                         const GrDrawTarget*) const {
     return GrPathRenderer::kStencilOnly_StencilSupport;
 }
 
@@ skipping 10 matching lines @@
                                                GrDrawTarget* target,
                                                bool antiAlias) {
     SkASSERT(!antiAlias);
     SkASSERT(!stroke.isHairlineStyle());
 
     GrDrawState* drawState = target->drawState();
     SkASSERT(drawState->getStencil().isDisabled());
 
     SkAutoTUnref<GrPath> p(fGpu->createPath(path));
 
-    SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(path.getFillType());
-    target->stencilPath(p, stroke, nonInvertedFill);
+    if (!path.isInverseFillType()) {
+        GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
+                                     kZero_StencilOp,
+                                     kZero_StencilOp,
+                                     kNotEqual_StencilFunc,
+                                     0xffff,
+                                     0x0000,
+                                 0xffff);
 
-    // TODO: Use built in cover operation rather than a rect draw. This will require making our
-    // fragment shaders be able to eat varyings generated by a matrix.
+        *drawState->stencil() = kStencilPass;
 
-    // fill the path, zero out the stencil
-    SkRect bounds = p->getBounds();
-    SkScalar bloat = drawState->getViewMatrix().getMaxStretch() * SK_ScalarHalf;
-    GrDrawState::AutoViewMatrixRestore avmr;
+        target->drawPath(p, stroke, path.getFillType());
+    } else {
+        SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(path.getFillType());
+        target->stencilPath(p, stroke, nonInvertedFill);
 
-    if (nonInvertedFill == path.getFillType()) {
-        GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
-            kZero_StencilOp,
-            kZero_StencilOp,
-            kNotEqual_StencilFunc,
-            0xffff,
-            0x0000,
-            0xffff);
-        *drawState->stencil() = kStencilPass;
-    } else {
+        GrDrawState::AutoViewMatrixRestore avmr;
+
         GR_STATIC_CONST_SAME_STENCIL(kInvertedStencilPass,
             kZero_StencilOp,
             kZero_StencilOp,
             // We know our rect will hit pixels outside the clip and the user bits will be 0
             // outside the clip. So we can't just fill where the user bits are 0. We also need to
             // check that the clip bit is set.
             kEqualIfInClip_StencilFunc,
             0xffff,
             0x0000,
             0xffff);
+
+
         SkMatrix vmi;
-        bounds.setLTRB(0, 0,
-                       SkIntToScalar(drawState->getRenderTarget()->width()),
-                       SkIntToScalar(drawState->getRenderTarget()->height()));
+        SkRect bounds = SkRect::MakeLTRB(0, 0,
+                                         SkIntToScalar(drawState->getRenderTarget()->width()),
+                                         SkIntToScalar(drawState->getRenderTarget()->height()));
         // mapRect through persp matrix may not be correct
         if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
             vmi.mapRect(&bounds);
             // theoretically could set bloat = 0, instead leave it because of matrix inversion
             // precision.
+            SkScalar bloat = drawState->getViewMatrix().getMaxStretch() * SK_ScalarHalf;
+            bounds.outset(bloat, bloat);
         } else {
             avmr.setIdentity(drawState);
-            bloat = 0;
         }
         *drawState->stencil() = kInvertedStencilPass;
+        target->drawSimpleRect(bounds, NULL);
     }
-    bounds.outset(bloat, bloat);
-    target->drawSimpleRect(bounds, NULL);
     target->drawState()->stencil()->setDisabled();
     return true;
 }