Separate user and raw stencil settings

src/gpu/GrDrawContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
@@ skipping 354 matching lines @@
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     this->internalDrawPath(clip, paint, viewMatrix, path,
                            strokeInfo ? *strokeInfo : GrStrokeInfo::FillInfo());
 }
 
 bool GrDrawContextPriv::drawAndStencilRect(const SkIRect* scissorRect,
-                                           const GrStencilSettings& ss,
+                                           const GrUserStencilSettings* ss,
                                            SkRegion::Op op,
                                            bool invert,
                                            bool doAA,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect) {
     ASSERT_SINGLE_OWNER_PRIV
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::stencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(doAA);
     paint.setCoverageSetOpXPFactory(op, invert);
 
     SkAutoTUnref<GrDrawBatch> batch(fDrawContext->getFillRectBatch(paint, viewMatrix, rect));
     if (batch) {
         GrPipelineBuilder pipelineBuilder(paint,
                                           fDrawContext->accessRenderTarget(),
                                           GrClip::WideOpen());
-        pipelineBuilder.setStencil(ss);
+        pipelineBuilder.setUserStencil(ss);
 
         fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, batch, scissorRect);
         return true;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     return this->drawAndStencilPath(scissorRect, ss, op, invert, doAA, viewMatrix, path);
 }
@@ skipping 441 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.
     this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
 }
 
 bool GrDrawContextPriv::drawAndStencilPath(const SkIRect* scissorRect,
-                                           const GrStencilSettings& ss,
+                                           const GrUserStencilSettings* ss,
                                            SkRegion::Op op,
                                            bool invert,
                                            bool doAA,
                                            const SkMatrix& viewMatrix,
                                            const SkPath& path) {
     ASSERT_SINGLE_OWNER_PRIV
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::drawPath");
 
     if (path.isEmpty() && path.isInverseFillType()) {
         this->drawAndStencilRect(scissorRect, ss, op, invert, false, SkMatrix::I(),
                                  SkRect::MakeIWH(fDrawContext->width(),
                                                  fDrawContext->height()));
         return true;
     }
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     // 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.
     bool useCoverageAA = doAA && !fDrawContext->fRenderTarget->isUnifiedMultisampled();
-    bool isStencilDisabled = true;
+    bool hasUserStencilSettings = (&GrUserStencilSettings::kUnused != ss);
     bool isStencilBufferMSAA = fDrawContext->fRenderTarget->isStencilBufferMultisampled();
 
     const GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
                       : GrPathRendererChain::kColor_DrawType;
 
     GrPathRenderer::CanDrawPathArgs canDrawArgs;
     canDrawArgs.fShaderCaps = fDrawContext->fDrawingManager->getContext()->caps()->shaderCaps();
     canDrawArgs.fViewMatrix = &viewMatrix;
     canDrawArgs.fPath = &path;
     canDrawArgs.fStroke = &GrStrokeInfo::FillInfo();
     canDrawArgs.fAntiAlias = useCoverageAA;
-    canDrawArgs.fIsStencilDisabled = isStencilDisabled;
+    canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
     canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
 
     // Don't allow the SW renderer
     GrPathRenderer* pr = fDrawContext->fDrawingManager->getPathRenderer(canDrawArgs, false, type);
     if (!pr) {
         return false;
     }
 
     GrPaint paint;
     paint.setCoverageSetOpXPFactory(op, invert);
 
     // TODO: it is unfortunate that we have to convert this to a GrClip to
     // call drawPath.
     GrClip clip;
     if (scissorRect) {
         clip.setIRect(*scissorRect);
     }
 
     GrPipelineBuilder pipelineBuilder(paint, fDrawContext->accessRenderTarget(), clip);
-    pipelineBuilder.setStencil(ss);
+    pipelineBuilder.setUserStencil(ss);
 
     GrPathRenderer::DrawPathArgs args;
     args.fTarget = fDrawContext->getDrawTarget();
     args.fResourceProvider = fDrawContext->fDrawingManager->getContext()->resourceProvider();
     args.fPipelineBuilder = &pipelineBuilder;
     args.fColor = GrColor_WHITE;
     args.fViewMatrix = &viewMatrix;
     args.fPath = &path;
     args.fStroke = &GrStrokeInfo::FillInfo();
     args.fAntiAlias = useCoverageAA;
     args.fGammaCorrect = fDrawContext->isGammaCorrect();
     pr->drawPath(args);
     return true;
 }
 
 void GrDrawContext::internalDrawPath(const GrClip& clip,
                                      const GrPaint& paint,
                                      const SkMatrix& viewMatrix,
                                      const SkPath& path,
                                      const GrStrokeInfo& strokeInfo) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     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.
     bool useCoverageAA = should_apply_coverage_aa(paint, fRenderTarget.get());
-    const bool isStencilDisabled = true;
+    constexpr bool kHasUserStencilSettings = false;
     bool isStencilBufferMSAA = fRenderTarget->isStencilBufferMultisampled();
 
     const GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
                       : GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
     GrPathRenderer::CanDrawPathArgs canDrawArgs;
     canDrawArgs.fShaderCaps = fDrawingManager->getContext()->caps()->shaderCaps();
     canDrawArgs.fViewMatrix = &viewMatrix;
     canDrawArgs.fPath = pathPtr;
     canDrawArgs.fStroke = strokeInfoPtr;
     canDrawArgs.fAntiAlias = useCoverageAA;
-    canDrawArgs.fIsStencilDisabled = isStencilDisabled;
+    canDrawArgs.fHasUserStencilSettings = kHasUserStencilSettings;
     canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
     GrPathRenderer* pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
 
     GrStrokeInfo dashlessStrokeInfo(strokeInfo, false);
     if (nullptr == pr && strokeInfo.isDashed()) {
         // It didn't work above, so try again with dashed stroke converted to a dashless stroke.
         if (!strokeInfo.applyDashToPath(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
             return;
@@ skipping 59 matching lines @@
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }