Clip mask manager sets stencil on draw type

src/gpu/GrClipMaskManager.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 "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
 #include "GrAAHairLinePathRenderer.h"
 #include "GrAARectRenderer.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrStencilBuffer.h"
 #include "GrSWMaskHelper.h"
+#include "SkRasterClip.h"
+#include "SkStrokeRec.h"
+#include "SkTLazy.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrRRectEffect.h"
-#include "SkRasterClip.h"
-#include "SkStrokeRec.h"
-#include "SkTLazy.h"
 
 #define GR_AA_CLIP 1
 
 typedef SkClipStack::Element Element;
 
 ////////////////////////////////////////////////////////////////////////////////
 namespace {
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
 void setup_drawstate_aaclip(GrGpu* gpu,
@@ skipping 169 matching lines @@
     }
 
     return !failed;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
                                       GrDrawState::AutoRestoreEffects* are,
+                                      GrDrawState::AutoRestoreStencil* asr,
                                       const SkRect* devBounds) {
     fCurrClipMaskType = kNone_ClipMaskType;
 
     GrReducedClip::ElementList elements(16);
     int32_t genID;
     GrReducedClip::InitialState initialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA;
 
     GrDrawState* drawState = fGpu->drawState();
 
     const GrRenderTarget* rt = drawState->getRenderTarget();
     // GrDrawTarget should have filtered this for us
     SkASSERT(rt);
 
     bool ignoreClip = !drawState->isClipState() || clipDataIn->fClipStack->isWideOpen();
-
-    if (!ignoreClip) {
-        SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
-        clipSpaceRTIBounds.offset(clipDataIn->fOrigin);
-        GrReducedClip::ReduceClipStack(*clipDataIn->fClipStack,
-                                       clipSpaceRTIBounds,
-                                       &elements,
-                                       &genID,
-                                       &initialState,
-                                       &clipSpaceIBounds,
-                                       &requiresAA);
-        if (elements.isEmpty()) {
-            if (GrReducedClip::kAllIn_InitialState == initialState) {
-                ignoreClip = clipSpaceIBounds == clipSpaceRTIBounds;
-            } else {
-                return false;
-            }
-        }
+    if (ignoreClip) {
+        fGpu->disableScissor();
+        this->setDrawStateStencil(asr);
+        return true;
     }
 
-    if (ignoreClip) {
-        fGpu->disableScissor();
-        this->setGpuStencil();
-        return true;
+    // Setup clip
+    SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
+    clipSpaceRTIBounds.offset(clipDataIn->fOrigin);
+    GrReducedClip::ReduceClipStack(*clipDataIn->fClipStack,
+                                   clipSpaceRTIBounds,
+                                   &elements,
+                                   &genID,
+                                   &initialState,
+                                   &clipSpaceIBounds,
+                                   &requiresAA);
+    if (elements.isEmpty()) {
+        if (GrReducedClip::kAllIn_InitialState == initialState) {
+            ignoreClip = clipSpaceIBounds == clipSpaceRTIBounds;

[bsalomon, 2014/10/24 21:04:38]

Does this get respected anymore now that the if (ignoreClip) was moved above?

+        } else {
+            return false;
+        }
     }
 
     // An element count of 4 was chosen because of the common pattern in Blink of:
     //   isect RR
     //   diff  RR
     //   isect convex_poly
     //   isect convex_poly
     // when drawing rounded div borders. This could probably be tuned based on a
     // configuration's relative costs of switching RTs to generate a mask vs
     // longer shaders.
     if (elements.count() <= 4) {
         SkVector clipToRTOffset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
                                     SkIntToScalar(-clipDataIn->fOrigin.fY) };
         if (elements.isEmpty() ||
             (requiresAA && this->installClipEffects(elements, are, clipToRTOffset, devBounds))) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clipDataIn->fOrigin);
             if (NULL == devBounds ||
                 !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
                 fGpu->enableScissor(scissorSpaceIBounds);
             } else {
                 fGpu->disableScissor();
             }
-            this->setGpuStencil();
+            this->setDrawStateStencil(asr);
             return true;
         }
     }
 
 #if GR_AA_CLIP
     // If MSAA is enabled we can do everything in the stencil buffer.
     if (0 == rt->numSamples() && requiresAA) {
         GrTexture* result = NULL;
 
         if (this->useSWOnlyPath(elements)) {
@@ skipping 11 matching lines @@
         }
 
         if (result) {
             // The mask's top left coord should be pinned to the rounded-out top left corner of
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
             rtSpaceMaskBounds.offset(-clipDataIn->fOrigin);
             are->set(fGpu->drawState());
             setup_drawstate_aaclip(fGpu, result, rtSpaceMaskBounds);
             fGpu->disableScissor();
-            this->setGpuStencil();
+            this->setDrawStateStencil(asr);
             return true;
         }
         // if alpha clip mask creation fails fall through to the non-AA code paths
     }
 #endif // GR_AA_CLIP
 
     // Either a hard (stencil buffer) clip was explicitly requested or an anti-aliased clip couldn't
     // be created. In either case, free up the texture in the anti-aliased mask cache.
     // TODO: this may require more investigation. Ganesh performs a lot of utility draws (e.g.,
     // clears, InOrderDrawBuffer playbacks) that hit the stencil buffer path. These may be
     // "incorrectly" clearing the AA cache.
     fAACache.reset();
 
     // use the stencil clip if we can't represent the clip as a rectangle.
     SkIPoint clipSpaceToStencilSpaceOffset = -clipDataIn->fOrigin;
     this->createStencilClipMask(genID,
                                 initialState,
                                 elements,
                                 clipSpaceIBounds,
                                 clipSpaceToStencilSpaceOffset);
 
     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
     // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
     // use both stencil and scissor test to the bounds for the final draw.
     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
     fGpu->enableScissor(scissorSpaceIBounds);
-    this->setGpuStencil();
+    this->setDrawStateStencil(asr);
     return true;
 }
 
 #define VISUALIZE_COMPLEX_CLIP 0
 
 #if VISUALIZE_COMPLEX_CLIP
     #include "SkRandom.h"
     SkRandom gRandom;
     #define SET_RANDOM_COLOR drawState->setColor(0xff000000 | gRandom.nextU());
 #else
@@ skipping 44 matching lines @@
 
     // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
             break;
         case Element::kRect_Type:
             // TODO: Do rects directly to the accumulator using a aa-rect GrProcessor that covers
             // the entire mask bounds and writes 0 outside the rect.
             if (element->isAA()) {
-                getContext()->getAARectRenderer()->fillAARect(fGpu,
-                                                              fGpu,
-                                                              element->getRect(),
-                                                              SkMatrix::I(),
-                                                              element->getRect());
+                this->getContext()->getAARectRenderer()->fillAARect(fGpu,
+                                                                    fGpu,
+                                                                    element->getRect(),
+                                                                    SkMatrix::I(),
+                                                                    element->getRect());
             } else {
                 fGpu->drawSimpleRect(element->getRect());
             }
             return true;
         default: {
             SkPath path;
             element->asPath(&path);
             path.setIsVolatile(true);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
@@ skipping 282 matching lines @@
     GrRenderTarget* rt = drawState->getRenderTarget();
     SkASSERT(rt);
 
     // TODO: dynamically attach a SB when needed.
     GrStencilBuffer* stencilBuffer = rt->getStencilBuffer();
     if (NULL == stencilBuffer) {
         return false;
     }
 
     if (stencilBuffer->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
-
         stencilBuffer->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
 
         // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
         SkVector translate = {
             SkIntToScalar(clipSpaceToStencilOffset.fX),
             SkIntToScalar(clipSpaceToStencilOffset.fY)
         };
         SkMatrix matrix;
         matrix.setTranslate(translate);
         GrDrawTarget::AutoGeometryAndStatePush agasp(fGpu, GrDrawTarget::kReset_ASRInit, &matrix);
@@ skipping 175 matching lines @@
         kKeep_StencilOp,
         kKeep_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0x0000,
         0x0000,
         0x0000);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
 }
 
-void GrClipMaskManager::setGpuStencil() {
+void GrClipMaskManager::setDrawStateStencil(GrDrawState::AutoRestoreStencil* ars) {
     // We make two copies of the StencilSettings here (except in the early
     // exit scenario. One copy from draw state to the stack var. Then another
     // from the stack var to the gpu. We could make this class hold a ptr to
     // GrGpu's fStencilSettings and eliminate the stack copy here.
 
     const GrDrawState& drawState = fGpu->getDrawState();
 
     // use stencil for clipping if clipping is enabled and the clip
     // has been written into the stencil.
     GrClipMaskManager::StencilClipMode clipMode;
     if (this->isClipInStencil() && drawState.isClipState()) {
         clipMode = GrClipMaskManager::kRespectClip_StencilClipMode;
         // We can't be modifying the clip and respecting it at the same time.
         SkASSERT(!drawState.isStateFlagEnabled(
                     GrGpu::kModifyStencilClip_StateBit));
     } else if (drawState.isStateFlagEnabled(
                     GrGpu::kModifyStencilClip_StateBit)) {
         clipMode = GrClipMaskManager::kModifyClip_StencilClipMode;
     } else {
         clipMode = GrClipMaskManager::kIgnoreClip_StencilClipMode;
     }
 
     GrStencilSettings settings;
     // The GrGpu client may not be using the stencil buffer but we may need to
     // enable it in order to respect a stencil clip.
     if (drawState.getStencil().isDisabled()) {
         if (GrClipMaskManager::kRespectClip_StencilClipMode == clipMode) {
             settings = basic_apply_stencil_clip_settings();
         } else {
-            fGpu->disableStencil();
             return;
         }
     } else {
         settings = drawState.getStencil();
     }
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
-    GrStencilBuffer* stencilBuffer =
-        drawState.getRenderTarget()->getStencilBuffer();
+    GrStencilBuffer* stencilBuffer = drawState.getRenderTarget()->getStencilBuffer();
     if (stencilBuffer) {
         stencilBits = stencilBuffer->bits();
     }
 
     SkASSERT(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
     SkASSERT(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
     this->adjustStencilParams(&settings, clipMode, stencilBits);
-    fGpu->setStencilSettings(settings);
+    ars->set(fGpu->drawState());
+    fGpu->drawState()->setStencil(settings);
 }
 
 void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings,
                                             StencilClipMode mode,
                                             int stencilBitCnt) {
     SkASSERT(stencilBitCnt > 0);
 
     if (kModifyClip_StencilClipMode == mode) {
         // We assume that this clip manager itself is drawing to the GrGpu and
         // has already setup the correct values.
@@ skipping 171 matching lines @@
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
     GrStencilBuffer* stencilBuffer =
         drawState.getRenderTarget()->getStencilBuffer();
     if (stencilBuffer) {
         stencilBits = stencilBuffer->bits();
         this->adjustStencilParams(settings, clipMode, stencilBits);
     }
 }