Initial CL to move color / coverage off of drawstate

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"
@@ skipping 342 matching lines @@
             break;
         default:
             SkASSERT(false);
             break;
     }
 }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrClipMaskManager::drawElement(GrDrawState* drawState,
+                                    GrColor color,
                                     GrTexture* target,
                                     const SkClipStack::Element* element,
                                     GrPathRenderer* pr) {
     GrDrawTarget::AutoGeometryPush agp(fClipTarget);
 
     drawState->setRenderTarget(target->asRenderTarget());
 
     // 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()) {
                 this->getContext()->getAARectRenderer()->fillAARect(fClipTarget,
                                                                     drawState,
+                                                                    color,
                                                                     element->getRect(),
                                                                     SkMatrix::I(),
                                                                     element->getRect());
             } else {
-                fClipTarget->drawSimpleRect(drawState, element->getRect());
+                fClipTarget->drawSimpleRect(drawState, color, element->getRect());
             }
             return true;
         default: {
             SkPath path;
             element->asPath(&path);
             path.setIsVolatile(true);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
             if (NULL == pr) {
                 GrPathRendererChain::DrawType type;
                 type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
                 pr = this->getContext()->getPathRenderer(fClipTarget, drawState, path, stroke,
                                                          false, type);
             }
             if (NULL == pr) {
                 return false;
             }
 
-            pr->drawPath(fClipTarget, drawState, path, stroke, element->isAA());
+            pr->drawPath(fClipTarget, drawState, color, path, stroke, element->isAA());
             break;
         }
     }
     return true;
 }
 
 bool GrClipMaskManager::canStencilAndDrawElement(GrDrawState* drawState,
                                                  GrTexture* target,
                                                  GrPathRenderer** pr,
                                                  const SkClipStack::Element* element) {
@@ skipping 33 matching lines @@
 
     SkMatrix sampleM;
     sampleM.setIDiv(srcMask->width(), srcMask->height());
 
     drawState->addColorProcessor(
         GrTextureDomainEffect::Create(srcMask,
                                       sampleM,
                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode))->unref();
-    fClipTarget->drawSimpleRect(drawState, SkRect::Make(dstBound));
+    fClipTarget->drawSimpleRect(drawState, GrColor_WHITE, SkRect::Make(dstBound));
 }
 
 GrTexture* GrClipMaskManager::createTempMask(int width, int height) {
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag|kNoStencil_GrSurfaceFlag;
     desc.fWidth = width;
     desc.fHeight = height;
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     return this->getContext()->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch);
@@ skipping 136 matching lines @@
                                              kReplace_StencilOp,
                                              kReplace_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0xffff,
                                              0xffff);
                 drawState.setStencil(kStencilInElement);
                 setup_boolean_blendcoeffs(op, &drawState);
             }
 
-            drawState.setAlpha(invert ? 0x00 : 0xff);
-
             // We have to backup the drawstate because the drawElement call may call into
             // renderers which consume it.
             GrDrawState backupDrawState(drawState);
 
-            if (!this->drawElement(&drawState, dst, element, pr)) {
+            if (!this->drawElement(&drawState, invert ? GrColor_BLACK : GrColor_WHITE, dst, element,
+                                   pr)) {
                 fAACache.reset();
                 return NULL;
             }
 
             if (useTemp) {
                 // Now draw into the accumulator using the real operation and the temp buffer as a
                 // texture
                 this->mergeMask(&backupDrawState,
                                 result,
                                 temp,
                                 op,
                                 maskSpaceIBounds,
                                 maskSpaceElementIBounds);
             } else {
                 // Draw to the exterior pixels (those with a zero stencil value).
-                backupDrawState.setAlpha(invert ? 0xff : 0x00);
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 backupDrawState.setStencil(kDrawOutsideElement);
-                fClipTarget->drawSimpleRect(&backupDrawState, clipSpaceIBounds);
+                fClipTarget->drawSimpleRect(&backupDrawState,
+                                            invert ? GrColor_WHITE : GrColor_BLACK,
+                                            clipSpaceIBounds);
             }
         } else {
             GrDrawState drawState(translate);
             drawState.enableState(GrDrawState::kCoverageDrawing_StateBit |
                                   GrDrawState::kClip_StateBit);
 
             // all the remaining ops can just be directly draw into the accumulation buffer
-            drawState.setAlpha(0xff);
             setup_boolean_blendcoeffs(op, &drawState);
-            this->drawElement(&drawState, result, element);
+            this->drawElement(&drawState, GrColor_WHITE, result, element);
         }
     }
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
@@ skipping 104 matching lines @@
             if (!canDrawDirectToClip) {
                 GR_STATIC_CONST_SAME_STENCIL(gDrawToStencil,
                                              kIncClamp_StencilOp,
                                              kIncClamp_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 if (Element::kRect_Type == element->getType()) {
                     *drawState.stencil() = gDrawToStencil;
-                    fClipTarget->drawSimpleRect(&drawState, element->getRect());
+                    fClipTarget->drawSimpleRect(&drawState, GrColor_WHITE, element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         GrDrawTarget::AutoGeometryPush agp(fClipTarget);
                         if (canRenderDirectToStencil) {
                             *drawState.stencil() = gDrawToStencil;
-                            pr->drawPath(fClipTarget, &drawState, clipPath, stroke, false);
+                            pr->drawPath(fClipTarget, &drawState, GrColor_WHITE, clipPath, stroke,
+                                         false);
                         } else {
                             pr->stencilPath(fClipTarget, &drawState, clipPath, stroke);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             fClipMode = kModifyClip_StencilClipMode;
             for (int p = 0; p < passes; ++p) {
                 GrDrawState drawStateCopy(drawState);
                 *drawStateCopy.stencil() = stencilSettings[p];
 
                 if (canDrawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
-                        fClipTarget->drawSimpleRect(&drawStateCopy, element->getRect());
+                        fClipTarget->drawSimpleRect(&drawStateCopy, GrColor_WHITE,
+                                                    element->getRect());
                     } else {
                         GrDrawTarget::AutoGeometryPush agp(fClipTarget);
-                        pr->drawPath(fClipTarget, &drawStateCopy, clipPath, stroke, false);
+                        pr->drawPath(fClipTarget, &drawStateCopy, GrColor_WHITE, clipPath, stroke, false);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    fClipTarget->drawSimpleRect(&drawStateCopy, SkRect::Make(clipSpaceIBounds));
+                    fClipTarget->drawSimpleRect(&drawStateCopy, GrColor_WHITE,
+                                                SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
     // set this last because recursive draws may overwrite it back to kNone.
     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     fCurrClipMaskType = kStencil_ClipMaskType;
     fClipMode = kRespectClip_StencilClipMode;
     return true;
 }
@@ skipping 249 matching lines @@
 }
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilBuffer* stencilBuffer,
                                                 GrStencilSettings* settings) {
     // TODO: dynamically attach a stencil buffer
     if (stencilBuffer) {
         int stencilBits = stencilBuffer->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }