src/third_party/skia/src/gpu/GrClipMaskManager.cpp

   1
   2 /*
   3  * Copyright 2012 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "GrClipMaskManager.h"
  10 #include "GrAAConvexPathRenderer.h"
  11 #include "GrAAHairLinePathRenderer.h"
  12 #include "GrAARectRenderer.h"
  13 #include "GrDrawTargetCaps.h"
  14 #include "GrGpu.h"
  15 #include "GrPaint.h"
  16 #include "GrPathRenderer.h"
  17 #include "GrRenderTarget.h"
  18 #include "GrStencilBuffer.h"
  19 #include "GrSWMaskHelper.h"
  20 #include "effects/GrTextureDomain.h"
  21 #include "effects/GrConvexPolyEffect.h"
  22 #include "effects/GrRRectEffect.h"
  23 #include "SkRasterClip.h"
  24 #include "SkStrokeRec.h"
  25 #include "SkTLazy.h"
  26
  27 #define GR_AA_CLIP 1
  28
  29 typedef SkClipStack::Element Element;
  30
  31 using namespace GrReducedClip;
  32
  33 ////////////////////////////////////////////////////////////////////////////////
  34 namespace {
  35 // set up the draw state to enable the aa clipping mask. Besides setting up the
  36 // stage matrix this also alters the vertex layout
  37 void setup_drawstate_aaclip(GrGpu* gpu,
  38                             GrTexture* result,
  39                             const SkIRect &devBound) {
  40     GrDrawState* drawState = gpu->drawState();
  41     SkASSERT(drawState);
  42
  43     SkMatrix mat;
  44     // We want to use device coords to compute the texture coordinates. We set our matrix to be
  45     // equal to the view matrix followed by an offset to the devBound, and then a scaling matrix to
  46     // normalized coords. We apply this matrix to the vertex positions rather than local coords.
  47     mat.setIDiv(result->width(), result->height());
  48     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
  49                      SkIntToScalar(-devBound.fTop));
  50     mat.preConcat(drawState->getViewMatrix());
  51
  52     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
  53     // This could be a long-lived effect that is cached with the alpha-mask.
  54     drawState->addCoverageProcessor(
  55         GrTextureDomainEffect::Create(result,
  56                                       mat,
  57                                       GrTextureDomain::MakeTexelDomain(result, domainTexels),
  58                                       GrTextureDomain::kDecal_Mode,
  59                                       GrTextureParams::kNone_FilterMode,
  60                                       kPosition_GrCoordSet))->unref();
  61 }
  62
  63 bool path_needs_SW_renderer(GrContext* context,
  64                             GrGpu* gpu,
  65                             const SkPath& origPath,
  66                             const SkStrokeRec& stroke,
  67                             bool doAA) {
  68     // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
  69     SkTCopyOnFirstWrite<SkPath> path(origPath);
  70     if (path->isInverseFillType()) {
  71         path.writable()->toggleInverseFillType();
  72     }
  73     // last (false) parameter disallows use of the SW path renderer
  74     GrPathRendererChain::DrawType type = doAA ?
  75                                          GrPathRendererChain::kColorAntiAlias_DrawType :
  76                                          GrPathRendererChain::kColor_DrawType;
  77
  78     return NULL == context->getPathRenderer(*path, stroke, gpu, false, type);
  79 }
  80
  81 }
  82
  83 /*
  84  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  85  * will be used on any element. If so, it returns true to indicate that the
  86  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  87  */
  88 bool GrClipMaskManager::useSWOnlyPath(const ElementList& elements) {
  89
  90     // TODO: generalize this function so that when
  91     // a clip gets complex enough it can just be done in SW regardless
  92     // of whether it would invoke the GrSoftwarePathRenderer.
  93     SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
  94
  95     for (ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
  96         const Element* element = iter.get();
  97         // rects can always be drawn directly w/o using the software path
  98         // Skip rrects once we're drawing them directly.
  99         if (Element::kRect_Type != element->getType()) {
 100             SkPath path;
 101             element->asPath(&path);
 102             if (path_needs_SW_renderer(this->getContext(), fGpu, path, stroke, element->isAA())) {
 103                 return true;
 104             }
 105         }
 106     }
 107     return false;
 108 }
 109
 110 bool GrClipMaskManager::installClipEffects(const ElementList& elements,
 111                                            GrDrawState::AutoRestoreEffects* are,
 112                                            const SkVector& clipToRTOffset,
 113                                            const SkRect* drawBounds) {
 114
 115     GrDrawState* drawState = fGpu->drawState();
 116     SkRect boundsInClipSpace;
 117     if (drawBounds) {
 118         boundsInClipSpace = *drawBounds;
 119         boundsInClipSpace.offset(-clipToRTOffset.fX, -clipToRTOffset.fY);
 120     }
 121
 122     are->set(drawState);
 123     GrRenderTarget* rt = drawState->getRenderTarget();
 124     ElementList::Iter iter(elements);
 125
 126     bool setARE = false;
 127     bool failed = false;
 128
 129     while (iter.get()) {
 130         SkRegion::Op op = iter.get()->getOp();
 131         bool invert;
 132         bool skip = false;
 133         switch (op) {
 134             case SkRegion::kReplace_Op:
 135                 SkASSERT(iter.get() == elements.head());
 136                 // Fallthrough, handled same as intersect.
 137             case SkRegion::kIntersect_Op:
 138                 invert = false;
 139                 if (drawBounds && iter.get()->contains(boundsInClipSpace)) {
 140                     skip = true;
 141                 }
 142                 break;
 143             case SkRegion::kDifference_Op:
 144                 invert = true;
 145                 // We don't currently have a cheap test for whether a rect is fully outside an
 146                 // element's primitive, so don't attempt to set skip.
 147                 break;
 148             default:
 149                 failed = true;
 150                 break;
 151         }
 152         if (failed) {
 153             break;
 154         }
 155
 156         if (!skip) {
 157             GrPrimitiveEdgeType edgeType;
 158             if (GR_AA_CLIP && iter.get()->isAA()) {
 159                 if (rt->isMultisampled()) {
 160                     // Coverage based AA clips don't place nicely with MSAA.
 161                     failed = true;
 162                     break;
 163                 }
 164                 edgeType =
 165                         invert ? kInverseFillAA_GrProcessorEdgeType : kFillAA_GrProcessorEdgeType;
 166             } else {
 167                 edgeType =
 168                         invert ? kInverseFillBW_GrProcessorEdgeType : kFillBW_GrProcessorEdgeType;
 169             }
 170             SkAutoTUnref<GrFragmentProcessor> fp;
 171             switch (iter.get()->getType()) {
 172                 case SkClipStack::Element::kPath_Type:
 173                     fp.reset(GrConvexPolyEffect::Create(edgeType, iter.get()->getPath(),
 174                         &clipToRTOffset));
 175                     break;
 176                 case SkClipStack::Element::kRRect_Type: {
 177                     SkRRect rrect = iter.get()->getRRect();
 178                     rrect.offset(clipToRTOffset.fX, clipToRTOffset.fY);
 179                     fp.reset(GrRRectEffect::Create(edgeType, rrect));
 180                     break;
 181                 }
 182                 case SkClipStack::Element::kRect_Type: {
 183                     SkRect rect = iter.get()->getRect();
 184                     rect.offset(clipToRTOffset.fX, clipToRTOffset.fY);
 185                     fp.reset(GrConvexPolyEffect::Create(edgeType, rect));
 186                     break;
 187                 }
 188                 default:
 189                     break;
 190             }
 191             if (fp) {
 192                 if (!setARE) {
 193                     are->set(fGpu->drawState());
 194                     setARE = true;
 195                 }
 196                 fGpu->drawState()->addCoverageProcessor(fp);
 197             } else {
 198                 failed = true;
 199                 break;
 200             }
 201         }
 202         iter.next();
 203     }
 204
 205     if (failed) {
 206         are->set(NULL);
 207     }
 208
 209     return !failed;
 210 }
 211
 212 ////////////////////////////////////////////////////////////////////////////////
 213 // sort out what kind of clip mask needs to be created: alpha, stencil,
 214 // scissor, or entirely software
 215 bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
 216                                       GrDrawState::AutoRestoreEffects* are,
 217                                       const SkRect* devBounds) {
 218     fCurrClipMaskType = kNone_ClipMaskType;
 219
 220     ElementList elements(16);
 221     int32_t genID;
 222     InitialState initialState;
 223     SkIRect clipSpaceIBounds;
 224     bool requiresAA;
 225
 226     GrDrawState* drawState = fGpu->drawState();
 227
 228     const GrRenderTarget* rt = drawState->getRenderTarget();
 229     // GrDrawTarget should have filtered this for us
 230     SkASSERT(rt);
 231
 232     bool ignoreClip = !drawState->isClipState() || clipDataIn->fClipStack->isWideOpen();
 233
 234     if (!ignoreClip) {
 235         SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
 236         clipSpaceRTIBounds.offset(clipDataIn->fOrigin);
 237         ReduceClipStack(*clipDataIn->fClipStack,
 238                         clipSpaceRTIBounds,
 239                         &elements,
 240                         &genID,
 241                         &initialState,
 242                         &clipSpaceIBounds,
 243                         &requiresAA);
 244         if (elements.isEmpty()) {
 245             if (kAllIn_InitialState == initialState) {
 246                 ignoreClip = clipSpaceIBounds == clipSpaceRTIBounds;
 247             } else {
 248                 return false;
 249             }
 250         }
 251     }
 252
 253     if (ignoreClip) {
 254         fGpu->disableScissor();
 255         this->setGpuStencil();
 256         return true;
 257     }
 258
 259     // An element count of 4 was chosen because of the common pattern in Blink of:
 260     //   isect RR
 261     //   diff  RR
 262     //   isect convex_poly
 263     //   isect convex_poly
 264     // when drawing rounded div borders. This could probably be tuned based on a
 265     // configuration's relative costs of switching RTs to generate a mask vs
 266     // longer shaders.
 267     if (elements.count() <= 4) {
 268         SkVector clipToRTOffset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
 269                                     SkIntToScalar(-clipDataIn->fOrigin.fY) };
 270         if (elements.isEmpty() ||
 271             (requiresAA && this->installClipEffects(elements, are, clipToRTOffset, devBounds))) {
 272             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
 273             scissorSpaceIBounds.offset(-clipDataIn->fOrigin);
 274             if (NULL == devBounds ||
 275                 !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
 276                 fGpu->enableScissor(scissorSpaceIBounds);
 277             } else {
 278                 fGpu->disableScissor();
 279             }
 280             this->setGpuStencil();
 281             return true;
 282         }
 283     }
 284
 285 #if GR_AA_CLIP
 286     // If MSAA is enabled we can do everything in the stencil buffer.
 287     if (0 == rt->numSamples() && requiresAA) {
 288         GrTexture* result = NULL;
 289
 290         if (this->useSWOnlyPath(elements)) {
 291             // The clip geometry is complex enough that it will be more efficient to create it
 292             // entirely in software
 293             result = this->createSoftwareClipMask(genID,
 294                                                   initialState,
 295                                                   elements,
 296                                                   clipSpaceIBounds);
 297         } else {
 298             result = this->createAlphaClipMask(genID,
 299                                                initialState,
 300                                                elements,
 301                                                clipSpaceIBounds);
 302         }
 303
 304         if (result) {
 305             // The mask's top left coord should be pinned to the rounded-out top left corner of
 306             // clipSpace bounds. We determine the mask's position WRT to the render target here.
 307             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
 308             rtSpaceMaskBounds.offset(-clipDataIn->fOrigin);
 309             are->set(fGpu->drawState());
 310             setup_drawstate_aaclip(fGpu, result, rtSpaceMaskBounds);
 311             fGpu->disableScissor();
 312             this->setGpuStencil();
 313             return true;
 314         }
 315         // if alpha clip mask creation fails fall through to the non-AA code paths
 316     }
 317 #endif // GR_AA_CLIP
 318
 319     // Either a hard (stencil buffer) clip was explicitly requested or an anti-aliased clip couldn't
 320     // be created. In either case, free up the texture in the anti-aliased mask cache.
 321     // TODO: this may require more investigation. Ganesh performs a lot of utility draws (e.g.,
 322     // clears, InOrderDrawBuffer playbacks) that hit the stencil buffer path. These may be
 323     // "incorrectly" clearing the AA cache.
 324     fAACache.reset();
 325
 326     // use the stencil clip if we can't represent the clip as a rectangle.
 327     SkIPoint clipSpaceToStencilSpaceOffset = -clipDataIn->fOrigin;
 328     this->createStencilClipMask(genID,
 329                                 initialState,
 330                                 elements,
 331                                 clipSpaceIBounds,
 332                                 clipSpaceToStencilSpaceOffset);
 333
 334     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
 335     // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
 336     // use both stencil and scissor test to the bounds for the final draw.
 337     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
 338     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
 339     fGpu->enableScissor(scissorSpaceIBounds);
 340     this->setGpuStencil();
 341     return true;
 342 }
 343
 344 #define VISUALIZE_COMPLEX_CLIP 0
 345
 346 #if VISUALIZE_COMPLEX_CLIP
 347     #include "SkRandom.h"
 348     SkRandom gRandom;
 349     #define SET_RANDOM_COLOR drawState->setColor(0xff000000 | gRandom.nextU());
 350 #else
 351     #define SET_RANDOM_COLOR
 352 #endif
 353
 354 namespace {
 355
 356 ////////////////////////////////////////////////////////////////////////////////
 357 // set up the OpenGL blend function to perform the specified
 358 // boolean operation for alpha clip mask creation
 359 void setup_boolean_blendcoeffs(GrDrawState* drawState, SkRegion::Op op) {
 360
 361     switch (op) {
 362         case SkRegion::kReplace_Op:
 363             drawState->setBlendFunc(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
 364             break;
 365         case SkRegion::kIntersect_Op:
 366             drawState->setBlendFunc(kDC_GrBlendCoeff, kZero_GrBlendCoeff);
 367             break;
 368         case SkRegion::kUnion_Op:
 369             drawState->setBlendFunc(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
 370             break;
 371         case SkRegion::kXOR_Op:
 372             drawState->setBlendFunc(kIDC_GrBlendCoeff, kISC_GrBlendCoeff);
 373             break;
 374         case SkRegion::kDifference_Op:
 375             drawState->setBlendFunc(kZero_GrBlendCoeff, kISC_GrBlendCoeff);
 376             break;
 377         case SkRegion::kReverseDifference_Op:
 378             drawState->setBlendFunc(kIDC_GrBlendCoeff, kZero_GrBlendCoeff);
 379             break;
 380         default:
 381             SkASSERT(false);
 382             break;
 383     }
 384 }
 385
 386 }
 387
 388 ////////////////////////////////////////////////////////////////////////////////
 389 bool GrClipMaskManager::drawElement(GrTexture* target,
 390                                     const SkClipStack::Element* element,
 391                                     GrPathRenderer* pr) {
 392     GrDrawState* drawState = fGpu->drawState();
 393
 394     drawState->setRenderTarget(target->asRenderTarget());
 395
 396     // TODO: Draw rrects directly here.
 397     switch (element->getType()) {
 398         case Element::kEmpty_Type:
 399             SkDEBUGFAIL("Should never get here with an empty element.");
 400             break;
 401         case Element::kRect_Type:
 402             // TODO: Do rects directly to the accumulator using a aa-rect GrProcessor that covers
 403             // the entire mask bounds and writes 0 outside the rect.
 404             if (element->isAA()) {
 405                 getContext()->getAARectRenderer()->fillAARect(fGpu,
 406                                                               fGpu,
 407                                                               element->getRect(),
 408                                                               SkMatrix::I(),
 409                                                               element->getRect());
 410             } else {
 411                 fGpu->drawSimpleRect(element->getRect());
 412             }
 413             return true;
 414         default: {
 415             SkPath path;
 416             element->asPath(&path);
 417             if (path.isInverseFillType()) {
 418                 path.toggleInverseFillType();
 419             }
 420             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 421             if (NULL == pr) {
 422                 GrPathRendererChain::DrawType type;
 423                 type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
 424                                          GrPathRendererChain::kColor_DrawType;
 425                 pr = this->getContext()->getPathRenderer(path, stroke, fGpu, false, type);
 426             }
 427             if (NULL == pr) {
 428                 return false;
 429             }
 430             pr->drawPath(path, stroke, fGpu, element->isAA());
 431             break;
 432         }
 433     }
 434     return true;
 435 }
 436
 437 bool GrClipMaskManager::canStencilAndDrawElement(GrTexture* target,
 438                                                  const SkClipStack::Element* element,
 439                                                  GrPathRenderer** pr) {
 440     GrDrawState* drawState = fGpu->drawState();
 441     drawState->setRenderTarget(target->asRenderTarget());
 442
 443     if (Element::kRect_Type == element->getType()) {
 444         return true;
 445     } else {
 446         // We shouldn't get here with an empty clip element.
 447         SkASSERT(Element::kEmpty_Type != element->getType());
 448         SkPath path;
 449         element->asPath(&path);
 450         if (path.isInverseFillType()) {
 451             path.toggleInverseFillType();
 452         }
 453         SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 454         GrPathRendererChain::DrawType type = element->isAA() ?
 455             GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
 456             GrPathRendererChain::kStencilAndColor_DrawType;
 457         *pr = this->getContext()->getPathRenderer(path, stroke, fGpu, false, type);
 458         return SkToBool(*pr);
 459     }
 460 }
 461
 462 void GrClipMaskManager::mergeMask(GrTexture* dstMask,
 463                                   GrTexture* srcMask,
 464                                   SkRegion::Op op,
 465                                   const SkIRect& dstBound,
 466                                   const SkIRect& srcBound) {
 467     GrDrawState::AutoViewMatrixRestore avmr;
 468     GrDrawState* drawState = fGpu->drawState();
 469     SkAssertResult(avmr.setIdentity(drawState));
 470     GrDrawState::AutoRestoreEffects are(drawState);
 471
 472     drawState->setRenderTarget(dstMask->asRenderTarget());
 473
 474     setup_boolean_blendcoeffs(drawState, op);
 475
 476     SkMatrix sampleM;
 477     sampleM.setIDiv(srcMask->width(), srcMask->height());
 478
 479     drawState->addColorProcessor(
 480         GrTextureDomainEffect::Create(srcMask,
 481                                       sampleM,
 482                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
 483                                       GrTextureDomain::kDecal_Mode,
 484                                       GrTextureParams::kNone_FilterMode))->unref();
 485     fGpu->drawSimpleRect(SkRect::Make(dstBound));
 486 }
 487
 488 // get a texture to act as a temporary buffer for AA clip boolean operations
 489 // TODO: given the expense of createTexture we may want to just cache this too
 490 void GrClipMaskManager::getTemp(int width, int height, GrAutoScratchTexture* temp) {
 491     if (temp->texture()) {
 492         // we've already allocated the temp texture
 493         return;
 494     }
 495
 496     GrTextureDesc desc;
 497     desc.fFlags = kRenderTarget_GrTextureFlagBit|kNoStencil_GrTextureFlagBit;
 498     desc.fWidth = width;
 499     desc.fHeight = height;
 500     desc.fConfig = kAlpha_8_GrPixelConfig;
 501
 502     temp->set(this->getContext(), desc);
 503 }
 504
 505 ////////////////////////////////////////////////////////////////////////////////
 506 // Return the texture currently in the cache if it exists. Otherwise, return NULL
 507 GrTexture* GrClipMaskManager::getCachedMaskTexture(int32_t elementsGenID,
 508                                                    const SkIRect& clipSpaceIBounds) {
 509     bool cached = fAACache.canReuse(elementsGenID, clipSpaceIBounds);
 510     if (!cached) {
 511         return NULL;
 512     }
 513
 514     return fAACache.getLastMask();
 515 }
 516
 517 ////////////////////////////////////////////////////////////////////////////////
 518 // Allocate a texture in the texture cache. This function returns the texture
 519 // allocated (or NULL on error).
 520 GrTexture* GrClipMaskManager::allocMaskTexture(int32_t elementsGenID,
 521                                                const SkIRect& clipSpaceIBounds,
 522                                                bool willUpload) {
 523     // Since we are setting up the cache we should free up the
 524     // currently cached mask so it can be reused.
 525     fAACache.reset();
 526
 527     GrTextureDesc desc;
 528     desc.fFlags = willUpload ? kNone_GrTextureFlags : kRenderTarget_GrTextureFlagBit;
 529     desc.fWidth = clipSpaceIBounds.width();
 530     desc.fHeight = clipSpaceIBounds.height();
 531     desc.fConfig = kRGBA_8888_GrPixelConfig;
 532     if (willUpload || this->getContext()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
 533         // We would always like A8 but it isn't supported on all platforms
 534         desc.fConfig = kAlpha_8_GrPixelConfig;
 535     }
 536
 537     fAACache.acquireMask(elementsGenID, desc, clipSpaceIBounds);
 538     return fAACache.getLastMask();
 539 }
 540
 541 ////////////////////////////////////////////////////////////////////////////////
 542 // Create a 8-bit clip mask in alpha
 543 GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID,
 544                                                   InitialState initialState,
 545                                                   const ElementList& elements,
 546                                                   const SkIRect& clipSpaceIBounds) {
 547     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 548
 549     // First, check for cached texture
 550     GrTexture* result = this->getCachedMaskTexture(elementsGenID, clipSpaceIBounds);
 551     if (result) {
 552         fCurrClipMaskType = kAlpha_ClipMaskType;
 553         return result;
 554     }
 555
 556     // There's no texture in the cache. Let's try to allocate it then.
 557     result = this->allocMaskTexture(elementsGenID, clipSpaceIBounds, false);
 558     if (NULL == result) {
 559         fAACache.reset();
 560         return NULL;
 561     }
 562
 563     // The top-left of the mask corresponds to the top-left corner of the bounds.
 564     SkVector clipToMaskOffset = {
 565         SkIntToScalar(-clipSpaceIBounds.fLeft),
 566         SkIntToScalar(-clipSpaceIBounds.fTop)
 567     };
 568     // The texture may be larger than necessary, this rect represents the part of the texture
 569     // we populate with a rasterization of the clip.
 570     SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
 571
 572     // Set the matrix so that rendered clip elements are transformed to mask space from clip space.
 573     SkMatrix translate;
 574     translate.setTranslate(clipToMaskOffset);
 575     GrDrawTarget::AutoGeometryAndStatePush agasp(fGpu, GrDrawTarget::kReset_ASRInit, &translate);
 576
 577     GrDrawState* drawState = fGpu->drawState();
 578
 579     // We're drawing a coverage mask and want coverage to be run through the blend function.
 580     drawState->enableState(GrDrawState::kCoverageDrawing_StateBit);
 581
 582     // The scratch texture that we are drawing into can be substantially larger than the mask. Only
 583     // clear the part that we care about.
 584     fGpu->clear(&maskSpaceIBounds,
 585                 kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
 586                 true,
 587                 result->asRenderTarget());
 588
 589     // When we use the stencil in the below loop it is important to have this clip installed.
 590     // The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
 591     // pass must not set values outside of this bounds or stencil values outside the rect won't be
 592     // cleared.
 593     GrDrawTarget::AutoClipRestore acr(fGpu, maskSpaceIBounds);
 594     drawState->enableState(GrDrawState::kClip_StateBit);
 595
 596     GrAutoScratchTexture temp;
 597     // walk through each clip element and perform its set op
 598     for (ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
 599         const Element* element = iter.get();
 600         SkRegion::Op op = element->getOp();
 601         bool invert = element->isInverseFilled();
 602
 603         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
 604             GrPathRenderer* pr = NULL;
 605             bool useTemp = !this->canStencilAndDrawElement(result, element, &pr);
 606             GrTexture* dst;
 607             // This is the bounds of the clip element in the space of the alpha-mask. The temporary
 608             // mask buffer can be substantially larger than the actually clip stack element. We
 609             // touch the minimum number of pixels necessary and use decal mode to combine it with
 610             // the accumulator.
 611             SkIRect maskSpaceElementIBounds;
 612
 613             if (useTemp) {
 614                 if (invert) {
 615                     maskSpaceElementIBounds = maskSpaceIBounds;
 616                 } else {
 617                     SkRect elementBounds = element->getBounds();
 618                     elementBounds.offset(clipToMaskOffset);
 619                     elementBounds.roundOut(&maskSpaceElementIBounds);
 620                 }
 621
 622                 this->getTemp(maskSpaceIBounds.fRight, maskSpaceIBounds.fBottom, &temp);
 623                 if (NULL == temp.texture()) {
 624                     fAACache.reset();
 625                     return NULL;
 626                 }
 627                 dst = temp.texture();
 628                 // clear the temp target and set blend to replace
 629                 fGpu->clear(&maskSpaceElementIBounds,
 630                             invert ? 0xffffffff : 0x00000000,
 631                             true,
 632                             dst->asRenderTarget());
 633                 setup_boolean_blendcoeffs(drawState, SkRegion::kReplace_Op);
 634
 635             } else {
 636                 // draw directly into the result with the stencil set to make the pixels affected
 637                 // by the clip shape be non-zero.
 638                 dst = result;
 639                 GR_STATIC_CONST_SAME_STENCIL(kStencilInElement,
 640                                              kReplace_StencilOp,
 641                                              kReplace_StencilOp,
 642                                              kAlways_StencilFunc,
 643                                              0xffff,
 644                                              0xffff,
 645                                              0xffff);
 646                 drawState->setStencil(kStencilInElement);
 647                 setup_boolean_blendcoeffs(drawState, op);
 648             }
 649
 650             drawState->setAlpha(invert ? 0x00 : 0xff);
 651
 652             if (!this->drawElement(dst, element, pr)) {
 653                 fAACache.reset();
 654                 return NULL;
 655             }
 656
 657             if (useTemp) {
 658                 // Now draw into the accumulator using the real operation and the temp buffer as a
 659                 // texture
 660                 this->mergeMask(result,
 661                                 temp.texture(),
 662                                 op,
 663                                 maskSpaceIBounds,
 664                                 maskSpaceElementIBounds);
 665             } else {
 666                 // Draw to the exterior pixels (those with a zero stencil value).
 667                 drawState->setAlpha(invert ? 0xff : 0x00);
 668                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
 669                                              kZero_StencilOp,
 670                                              kZero_StencilOp,
 671                                              kEqual_StencilFunc,
 672                                              0xffff,
 673                                              0x0000,
 674                                              0xffff);
 675                 drawState->setStencil(kDrawOutsideElement);
 676                 fGpu->drawSimpleRect(clipSpaceIBounds);
 677                 drawState->disableStencil();
 678             }
 679         } else {
 680             // all the remaining ops can just be directly draw into the accumulation buffer
 681             drawState->setAlpha(0xff);
 682             setup_boolean_blendcoeffs(drawState, op);
 683             this->drawElement(result, element);
 684         }
 685     }
 686
 687     fCurrClipMaskType = kAlpha_ClipMaskType;
 688     return result;
 689 }
 690
 691 ////////////////////////////////////////////////////////////////////////////////
 692 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 693 // (as opposed to canvas) coordinates
 694 bool GrClipMaskManager::createStencilClipMask(int32_t elementsGenID,
 695                                               InitialState initialState,
 696                                               const ElementList& elements,
 697                                               const SkIRect& clipSpaceIBounds,
 698                                               const SkIPoint& clipSpaceToStencilOffset) {
 699
 700     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 701
 702     GrDrawState* drawState = fGpu->drawState();
 703     SkASSERT(drawState->isClipState());
 704
 705     GrRenderTarget* rt = drawState->getRenderTarget();
 706     SkASSERT(rt);
 707
 708     // TODO: dynamically attach a SB when needed.
 709     GrStencilBuffer* stencilBuffer = rt->getStencilBuffer();
 710     if (NULL == stencilBuffer) {
 711         return false;
 712     }
 713
 714     if (stencilBuffer->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
 715
 716         stencilBuffer->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
 717
 718         // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
 719         SkVector translate = {
 720             SkIntToScalar(clipSpaceToStencilOffset.fX),
 721             SkIntToScalar(clipSpaceToStencilOffset.fY)
 722         };
 723         SkMatrix matrix;
 724         matrix.setTranslate(translate);
 725         GrDrawTarget::AutoGeometryAndStatePush agasp(fGpu, GrDrawTarget::kReset_ASRInit, &matrix);
 726         drawState = fGpu->drawState();
 727
 728         drawState->setRenderTarget(rt);
 729
 730         // We set the current clip to the bounds so that our recursive draws are scissored to them.
 731         SkIRect stencilSpaceIBounds(clipSpaceIBounds);
 732         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
 733         GrDrawTarget::AutoClipRestore acr(fGpu, stencilSpaceIBounds);
 734         drawState->enableState(GrDrawState::kClip_StateBit);
 735
 736 #if !VISUALIZE_COMPLEX_CLIP
 737         drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
 738 #endif
 739
 740         int clipBit = stencilBuffer->bits();
 741         SkASSERT((clipBit <= 16) && "Ganesh only handles 16b or smaller stencil buffers");
 742         clipBit = (1 << (clipBit-1));
 743
 744         fGpu->clearStencilClip(rt, stencilSpaceIBounds, kAllIn_InitialState == initialState);
 745
 746         // walk through each clip element and perform its set op
 747         // with the existing clip.
 748         for (ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
 749             const Element* element = iter.get();
 750             bool fillInverted = false;
 751             // enabled at bottom of loop
 752             drawState->disableState(GrGpu::kModifyStencilClip_StateBit);
 753             // if the target is MSAA then we want MSAA enabled when the clip is soft
 754             if (rt->isMultisampled()) {
 755                 drawState->setState(GrDrawState::kHWAntialias_StateBit, element->isAA());
 756             }
 757
 758             // This will be used to determine whether the clip shape can be rendered into the
 759             // stencil with arbitrary stencil settings.
 760             GrPathRenderer::StencilSupport stencilSupport;
 761
 762             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 763
 764             SkRegion::Op op = element->getOp();
 765
 766             GrPathRenderer* pr = NULL;
 767             SkPath clipPath;
 768             if (Element::kRect_Type == element->getType()) {
 769                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
 770                 fillInverted = false;
 771             } else {
 772                 element->asPath(&clipPath);
 773                 fillInverted = clipPath.isInverseFillType();
 774                 if (fillInverted) {
 775                     clipPath.toggleInverseFillType();
 776                 }
 777                 pr = this->getContext()->getPathRenderer(clipPath,
 778                                                          stroke,
 779                                                          fGpu,
 780                                                          false,
 781                                                          GrPathRendererChain::kStencilOnly_DrawType,
 782                                                          &stencilSupport);
 783                 if (NULL == pr) {
 784                     return false;
 785                 }
 786             }
 787
 788             int passes;
 789             GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
 790
 791             bool canRenderDirectToStencil =
 792                 GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport;
 793             bool canDrawDirectToClip; // Given the renderer, the element,
 794                                       // fill rule, and set operation can
 795                                       // we render the element directly to
 796                                       // stencil bit used for clipping.
 797             canDrawDirectToClip = GrStencilSettings::GetClipPasses(op,
 798                                                                    canRenderDirectToStencil,
 799                                                                    clipBit,
 800                                                                    fillInverted,
 801                                                                    &passes,
 802                                                                    stencilSettings);
 803
 804             // draw the element to the client stencil bits if necessary
 805             if (!canDrawDirectToClip) {
 806                 GR_STATIC_CONST_SAME_STENCIL(gDrawToStencil,
 807                                              kIncClamp_StencilOp,
 808                                              kIncClamp_StencilOp,
 809                                              kAlways_StencilFunc,
 810                                              0xffff,
 811                                              0x0000,
 812                                              0xffff);
 813                 SET_RANDOM_COLOR
 814                 if (Element::kRect_Type == element->getType()) {
 815                     *drawState->stencil() = gDrawToStencil;
 816                     fGpu->drawSimpleRect(element->getRect());
 817                 } else {
 818                     if (!clipPath.isEmpty()) {
 819                         if (canRenderDirectToStencil) {
 820                             *drawState->stencil() = gDrawToStencil;
 821                             pr->drawPath(clipPath, stroke, fGpu, false);
 822                         } else {
 823                             pr->stencilPath(clipPath, stroke, fGpu);
 824                         }
 825                     }
 826                 }
 827             }
 828
 829             // now we modify the clip bit by rendering either the clip
 830             // element directly or a bounding rect of the entire clip.
 831             drawState->enableState(GrGpu::kModifyStencilClip_StateBit);
 832             for (int p = 0; p < passes; ++p) {
 833                 *drawState->stencil() = stencilSettings[p];
 834                 if (canDrawDirectToClip) {
 835                     if (Element::kRect_Type == element->getType()) {
 836                         SET_RANDOM_COLOR
 837                         fGpu->drawSimpleRect(element->getRect());
 838                     } else {
 839                         SET_RANDOM_COLOR
 840                         pr->drawPath(clipPath, stroke, fGpu, false);
 841                     }
 842                 } else {
 843                     SET_RANDOM_COLOR
 844                     // The view matrix is setup to do clip space -> stencil space translation, so
 845                     // draw rect in clip space.
 846                     fGpu->drawSimpleRect(SkRect::Make(clipSpaceIBounds));
 847                 }
 848             }
 849         }
 850     }
 851     // set this last because recursive draws may overwrite it back to kNone.
 852     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 853     fCurrClipMaskType = kStencil_ClipMaskType;
 854     return true;
 855 }
 856
 857
 858 // mapping of clip-respecting stencil funcs to normal stencil funcs
 859 // mapping depends on whether stencil-clipping is in effect.
 860 static const GrStencilFunc
 861     gSpecialToBasicStencilFunc[2][kClipStencilFuncCount] = {
 862     {// Stencil-Clipping is DISABLED,  we are effectively always inside the clip
 863         // In the Clip Funcs
 864         kAlways_StencilFunc,          // kAlwaysIfInClip_StencilFunc
 865         kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
 866         kLess_StencilFunc,            // kLessIfInClip_StencilFunc
 867         kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
 868         // Special in the clip func that forces user's ref to be 0.
 869         kNotEqual_StencilFunc,        // kNonZeroIfInClip_StencilFunc
 870                                       // make ref 0 and do normal nequal.
 871     },
 872     {// Stencil-Clipping is ENABLED
 873         // In the Clip Funcs
 874         kEqual_StencilFunc,           // kAlwaysIfInClip_StencilFunc
 875                                       // eq stencil clip bit, mask
 876                                       // out user bits.
 877
 878         kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
 879                                       // add stencil bit to mask and ref
 880
 881         kLess_StencilFunc,            // kLessIfInClip_StencilFunc
 882         kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
 883                                       // for both of these we can add
 884                                       // the clip bit to the mask and
 885                                       // ref and compare as normal
 886         // Special in the clip func that forces user's ref to be 0.
 887         kLess_StencilFunc,            // kNonZeroIfInClip_StencilFunc
 888                                       // make ref have only the clip bit set
 889                                       // and make comparison be less
 890                                       // 10..0 < 1..user_bits..
 891     }
 892 };
 893
 894 namespace {
 895 // Sets the settings to clip against the stencil buffer clip while ignoring the
 896 // client bits.
 897 const GrStencilSettings& basic_apply_stencil_clip_settings() {
 898     // stencil settings to use when clip is in stencil
 899     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
 900         kKeep_StencilOp,
 901         kKeep_StencilOp,
 902         kAlwaysIfInClip_StencilFunc,
 903         0x0000,
 904         0x0000,
 905         0x0000);
 906     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 907 }
 908 }
 909
 910 void GrClipMaskManager::setGpuStencil() {
 911     // We make two copies of the StencilSettings here (except in the early
 912     // exit scenario. One copy from draw state to the stack var. Then another
 913     // from the stack var to the gpu. We could make this class hold a ptr to
 914     // GrGpu's fStencilSettings and eliminate the stack copy here.
 915
 916     const GrDrawState& drawState = fGpu->getDrawState();
 917
 918     // use stencil for clipping if clipping is enabled and the clip
 919     // has been written into the stencil.
 920     GrClipMaskManager::StencilClipMode clipMode;
 921     if (this->isClipInStencil() && drawState.isClipState()) {
 922         clipMode = GrClipMaskManager::kRespectClip_StencilClipMode;
 923         // We can't be modifying the clip and respecting it at the same time.
 924         SkASSERT(!drawState.isStateFlagEnabled(
 925                     GrGpu::kModifyStencilClip_StateBit));
 926     } else if (drawState.isStateFlagEnabled(
 927                     GrGpu::kModifyStencilClip_StateBit)) {
 928         clipMode = GrClipMaskManager::kModifyClip_StencilClipMode;
 929     } else {
 930         clipMode = GrClipMaskManager::kIgnoreClip_StencilClipMode;
 931     }
 932
 933     GrStencilSettings settings;
 934     // The GrGpu client may not be using the stencil buffer but we may need to
 935     // enable it in order to respect a stencil clip.
 936     if (drawState.getStencil().isDisabled()) {
 937         if (GrClipMaskManager::kRespectClip_StencilClipMode == clipMode) {
 938             settings = basic_apply_stencil_clip_settings();
 939         } else {
 940             fGpu->disableStencil();
 941             return;
 942         }
 943     } else {
 944         settings = drawState.getStencil();
 945     }
 946
 947     // TODO: dynamically attach a stencil buffer
 948     int stencilBits = 0;
 949     GrStencilBuffer* stencilBuffer =
 950         drawState.getRenderTarget()->getStencilBuffer();
 951     if (stencilBuffer) {
 952         stencilBits = stencilBuffer->bits();
 953     }
 954
 955     SkASSERT(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
 956     SkASSERT(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
 957     this->adjustStencilParams(&settings, clipMode, stencilBits);
 958     fGpu->setStencilSettings(settings);
 959 }
 960
 961 void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings,
 962                                             StencilClipMode mode,
 963                                             int stencilBitCnt) {
 964     SkASSERT(stencilBitCnt > 0);
 965
 966     if (kModifyClip_StencilClipMode == mode) {
 967         // We assume that this clip manager itself is drawing to the GrGpu and
 968         // has already setup the correct values.
 969         return;
 970     }
 971
 972     unsigned int clipBit = (1 << (stencilBitCnt - 1));
 973     unsigned int userBits = clipBit - 1;
 974
 975     GrStencilSettings::Face face = GrStencilSettings::kFront_Face;
 976     bool twoSided = fGpu->caps()->twoSidedStencilSupport();
 977
 978     bool finished = false;
 979     while (!finished) {
 980         GrStencilFunc func = settings->func(face);
 981         uint16_t writeMask = settings->writeMask(face);
 982         uint16_t funcMask = settings->funcMask(face);
 983         uint16_t funcRef = settings->funcRef(face);
 984
 985         SkASSERT((unsigned) func < kStencilFuncCount);
 986
 987         writeMask &= userBits;
 988
 989         if (func >= kBasicStencilFuncCount) {
 990             int respectClip = kRespectClip_StencilClipMode == mode;
 991             if (respectClip) {
 992                 // The GrGpu class should have checked this
 993                 SkASSERT(this->isClipInStencil());
 994                 switch (func) {
 995                     case kAlwaysIfInClip_StencilFunc:
 996                         funcMask = clipBit;
 997                         funcRef = clipBit;
 998                         break;
 999                     case kEqualIfInClip_StencilFunc:
1000                     case kLessIfInClip_StencilFunc:
1001                     case kLEqualIfInClip_StencilFunc:
1002                         funcMask = (funcMask & userBits) | clipBit;
1003                         funcRef  = (funcRef  & userBits) | clipBit;
1004                         break;
1005                     case kNonZeroIfInClip_StencilFunc:
1006                         funcMask = (funcMask & userBits) | clipBit;
1007                         funcRef = clipBit;
1008                         break;
1009                     default:
1010                         SkFAIL("Unknown stencil func");
1011                 }
1012             } else {
1013                 funcMask &= userBits;
1014                 funcRef &= userBits;
1015             }
1016             const GrStencilFunc* table =
1017                 gSpecialToBasicStencilFunc[respectClip];
1018             func = table[func - kBasicStencilFuncCount];
1019             SkASSERT(func >= 0 && func < kBasicStencilFuncCount);
1020         } else {
1021             funcMask &= userBits;
1022             funcRef &= userBits;
1023         }
1024
1025         settings->setFunc(face, func);
1026         settings->setWriteMask(face, writeMask);
1027         settings->setFuncMask(face, funcMask);
1028         settings->setFuncRef(face, funcRef);
1029
1030         if (GrStencilSettings::kFront_Face == face) {
1031             face = GrStencilSettings::kBack_Face;
1032             finished = !twoSided;
1033         } else {
1034             finished = true;
1035         }
1036     }
1037     if (!twoSided) {
1038         settings->copyFrontSettingsToBack();
1039     }
1040 }
1041
1042 ////////////////////////////////////////////////////////////////////////////////
1043 GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t elementsGenID,
1044                                                      GrReducedClip::InitialState initialState,
1045                                                      const GrReducedClip::ElementList& elements,
1046                                                      const SkIRect& clipSpaceIBounds) {
1047     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
1048
1049     GrTexture* result = this->getCachedMaskTexture(elementsGenID, clipSpaceIBounds);
1050     if (result) {
1051         return result;
1052     }
1053
1054     // The mask texture may be larger than necessary. We round out the clip space bounds and pin
1055     // the top left corner of the resulting rect to the top left of the texture.
1056     SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
1057
1058     GrSWMaskHelper helper(this->getContext());
1059
1060     SkMatrix matrix;
1061     matrix.setTranslate(SkIntToScalar(-clipSpaceIBounds.fLeft),
1062                         SkIntToScalar(-clipSpaceIBounds.fTop));
1063     helper.init(maskSpaceIBounds, &matrix, false);
1064
1065     helper.clear(kAllIn_InitialState == initialState ? 0xFF : 0x00);
1066
1067     SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
1068
1069     for (ElementList::Iter iter(elements.headIter()) ; iter.get(); iter.next()) {
1070
1071         const Element* element = iter.get();
1072         SkRegion::Op op = element->getOp();
1073
1074         if (SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
1075             // Intersect and reverse difference require modifying pixels outside of the geometry
1076             // that is being "drawn". In both cases we erase all the pixels outside of the geometry
1077             // but leave the pixels inside the geometry alone. For reverse difference we invert all
1078             // the pixels before clearing the ones outside the geometry.
1079             if (SkRegion::kReverseDifference_Op == op) {
1080                 SkRect temp = SkRect::Make(clipSpaceIBounds);
1081                 // invert the entire scene
1082                 helper.draw(temp, SkRegion::kXOR_Op, false, 0xFF);
1083             }
1084
1085             SkPath clipPath;
1086             element->asPath(&clipPath);
1087             clipPath.toggleInverseFillType();
1088             helper.draw(clipPath, stroke, SkRegion::kReplace_Op, element->isAA(), 0x00);
1089
1090             continue;
1091         }
1092
1093         // The other ops (union, xor, diff) only affect pixels inside
1094         // the geometry so they can just be drawn normally
1095         if (Element::kRect_Type == element->getType()) {
1096             helper.draw(element->getRect(), op, element->isAA(), 0xFF);
1097         } else {
1098             SkPath path;
1099             element->asPath(&path);
1100             helper.draw(path, stroke, op, element->isAA(), 0xFF);
1101         }
1102     }
1103
1104     // Allocate clip mask texture
1105     result = this->allocMaskTexture(elementsGenID, clipSpaceIBounds, true);
1106     if (NULL == result) {
1107         fAACache.reset();
1108         return NULL;
1109     }
1110     helper.toTexture(result);
1111
1112     fCurrClipMaskType = kAlpha_ClipMaskType;
1113     return result;
1114 }
1115
1116 ////////////////////////////////////////////////////////////////////////////////
1117 void GrClipMaskManager::purgeResources() {
1118     fAACache.purgeResources();
1119 }
1120
1121 void GrClipMaskManager::setGpu(GrGpu* gpu) {
1122     fGpu = gpu;
1123     fAACache.setContext(gpu->getContext());
1124 }
1125
1126 void GrClipMaskManager::adjustPathStencilParams(GrStencilSettings* settings) {
1127     const GrDrawState& drawState = fGpu->getDrawState();
1128     GrClipMaskManager::StencilClipMode clipMode;
1129     if (this->isClipInStencil() && drawState.isClipState()) {
1130         clipMode = GrClipMaskManager::kRespectClip_StencilClipMode;
1131         // We can't be modifying the clip and respecting it at the same time.
1132         SkASSERT(!drawState.isStateFlagEnabled(
1133                     GrGpu::kModifyStencilClip_StateBit));
1134     } else if (drawState.isStateFlagEnabled(
1135                     GrGpu::kModifyStencilClip_StateBit)) {
1136         clipMode = GrClipMaskManager::kModifyClip_StencilClipMode;
1137     } else {
1138         clipMode = GrClipMaskManager::kIgnoreClip_StencilClipMode;
1139     }
1140
1141     // TODO: dynamically attach a stencil buffer
1142     int stencilBits = 0;
1143     GrStencilBuffer* stencilBuffer =
1144         drawState.getRenderTarget()->getStencilBuffer();
1145     if (stencilBuffer) {
1146         stencilBits = stencilBuffer->bits();
1147         this->adjustStencilParams(settings, clipMode, stencilBits);
1148     }
1149 }