Separate user and raw stencil settings

src/gpu/batches/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"
 #include "GrCaps.h"
@@ skipping 18 matching lines @@
 GrStencilAndCoverPathRenderer::GrStencilAndCoverPathRenderer(GrResourceProvider* resourceProvider)
     : fResourceProvider(resourceProvider) {
 }
 
 bool GrStencilAndCoverPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // GrPath doesn't support hairline paths. Also, an arbitrary path effect could change
     // the style type to hairline.
     if (args.fStyle->hasNonDashPathEffect() || args.fStyle->strokeRec().isHairlineStyle()) {
         return false;
     }
-    if (!args.fIsStencilDisabled) {
+    if (args.fHasUserStencilSettings) {
         return false;
     }
     if (args.fAntiAlias) {
         return args.fIsStencilBufferMSAA;
     } else {
         return true; // doesn't do per-path AA, relies on the target having MSAA
     }
 }
 
 static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const SkPath& skPath,
@@ skipping 23 matching lines @@
 }
 
 bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
                               "GrStencilAndCoverPathRenderer::onDrawPath");
     SkASSERT(!args.fStyle->strokeRec().isHairlineStyle());
     const SkPath& path = *args.fPath;
     GrPipelineBuilder* pipelineBuilder = args.fPipelineBuilder;
     const SkMatrix& viewMatrix = *args.fViewMatrix;
 
-    SkASSERT(pipelineBuilder->getStencil().isDisabled());
+    SkASSERT(!pipelineBuilder->hasUserStencilSettings());
 
     if (args.fAntiAlias) {
         SkASSERT(pipelineBuilder->getRenderTarget()->isStencilBufferMultisampled());
         pipelineBuilder->enableState(GrPipelineBuilder::kHWAntialias_Flag);
     }
 
     SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, path, *args.fStyle));
 
     if (path.isInverseFillType()) {
-        static constexpr GrStencilSettings kInvertedStencilPass(
-            kKeep_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);
+        static constexpr GrUserStencilSettings kInvertedCoverPass(
+            GrUserStencilSettings::StaticInit<
+                0x0000,
+                // 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.
+                GrUserStencilTest::kEqualIfInClip,
+                0xffff,
+                GrUserStencilOp::kKeep,
+                GrUserStencilOp::kZero,
+                0xffff>()
+        );
 
-        pipelineBuilder->setStencil(kInvertedStencilPass);
+
+        pipelineBuilder->setUserStencil(&kInvertedCoverPass);
 
         // fake inverse with a stencil and cover
         args.fTarget->stencilPath(*pipelineBuilder, viewMatrix, p, p->getFillType());
 
         SkMatrix invert = SkMatrix::I();
         SkRect bounds =
             SkRect::MakeLTRB(0, 0, SkIntToScalar(pipelineBuilder->getRenderTarget()->width()),
                              SkIntToScalar(pipelineBuilder->getRenderTarget()->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
@@ skipping 11 matching lines @@
         const SkMatrix& viewM = viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix;
         if (pipelineBuilder->getRenderTarget()->hasMixedSamples()) {
             pipelineBuilder->disableState(GrPipelineBuilder::kHWAntialias_Flag);
         }
 
         SkAutoTUnref<GrDrawBatch> batch(
                 GrRectBatchFactory::CreateNonAAFill(args.fColor, viewM, bounds, nullptr,
                                                     &invert));
         args.fTarget->drawBatch(*pipelineBuilder, batch);
     } else {
-        static constexpr GrStencilSettings kStencilPass(
-            kZero_StencilOp,
-            kKeep_StencilOp,
-            kNotEqual_StencilFunc,
-            0xffff,
-            0x0000,
-            0xffff);
+        static constexpr GrUserStencilSettings kCoverPass(
+            GrUserStencilSettings::StaticInit<
+                0x0000,
+                GrUserStencilTest::kNotEqual,
+                0xffff,
+                GrUserStencilOp::kZero,
+                GrUserStencilOp::kKeep,
+                0xffff>()
+        );
 
-        pipelineBuilder->setStencil(kStencilPass);
+        pipelineBuilder->setUserStencil(&kCoverPass);
         SkAutoTUnref<GrDrawPathBatchBase> batch(
                 GrDrawPathBatch::Create(viewMatrix, args.fColor, p->getFillType(), p));
         args.fTarget->drawPathBatch(*pipelineBuilder, batch);
     }
 
-    pipelineBuilder->stencil()->setDisabled();
+    pipelineBuilder->disableUserStencil();
     return true;
 }