Add Coverage Drawing XP

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 312 matching lines @@
     // use both stencil and scissor test to the bounds for the final draw.
     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
     scissorState->set(scissorSpaceIBounds);
     this->setDrawStateStencil(drawState, ars);
     return true;
 }
 
 namespace {
 ////////////////////////////////////////////////////////////////////////////////
-// set up the OpenGL blend function to perform the specified
-// boolean operation for alpha clip mask creation
-void setup_boolean_blendcoeffs(SkRegion::Op op, GrDrawState* drawState) {
-    // TODO: once we have a coverageDrawing XP this will all use that instead of PD
-    switch (op) {
-        case SkRegion::kReplace_Op:
-            drawState->setPorterDuffXPFactory(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
-            break;
-        case SkRegion::kIntersect_Op:
-            drawState->setPorterDuffXPFactory(kDC_GrBlendCoeff, kZero_GrBlendCoeff);
-            break;
-        case SkRegion::kUnion_Op:
-            drawState->setPorterDuffXPFactory(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
-            break;
-        case SkRegion::kXOR_Op:
-            drawState->setPorterDuffXPFactory(kIDC_GrBlendCoeff, kISC_GrBlendCoeff);
-            break;
-        case SkRegion::kDifference_Op:
-            drawState->setPorterDuffXPFactory(kZero_GrBlendCoeff, kISC_GrBlendCoeff);
-            break;
-        case SkRegion::kReverseDifference_Op:
-            drawState->setPorterDuffXPFactory(kIDC_GrBlendCoeff, kZero_GrBlendCoeff);
-            break;
-        default:
-            SkASSERT(false);
-            break;
-    }
+// Set a coverage drawing XPF on the drawState for the given op and invertCoverage mode
+void set_coverage_drawing_xpf(SkRegion::Op op, bool invertCoverage, GrDrawState* drawState) {
+    SkASSERT(op <= SkRegion::kLastOp);
+    drawState->setCoverageSetOpXPFactory(op, invertCoverage);
 }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrClipMaskManager::drawElement(GrDrawState* drawState,
-                                    GrColor color,
                                     GrTexture* target,
                                     const SkClipStack::Element* element,
                                     GrPathRenderer* pr) {
     GrDrawTarget::AutoGeometryPush agp(fClipTarget);
 
     drawState->setRenderTarget(target->asRenderTarget());
 
+    // The color we use to draw does not matter since we will always be using a GrCoverageSetOpXP
+    // which ignores color.
+    GrColor color = GrColor_WHITE;
+
     // 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,
@@ skipping 61 matching lines @@
 void GrClipMaskManager::mergeMask(GrDrawState* drawState,
                                   GrTexture* dstMask,
                                   GrTexture* srcMask,
                                   SkRegion::Op op,
                                   const SkIRect& dstBound,
                                   const SkIRect& srcBound) {
     SkAssertResult(drawState->setIdentityViewMatrix());
 
     drawState->setRenderTarget(dstMask->asRenderTarget());
 
-    setup_boolean_blendcoeffs(op, drawState);
+    // We want to invert the coverage here
+    set_coverage_drawing_xpf(op, false, drawState);
 
     SkMatrix sampleM;
     sampleM.setIDiv(srcMask->width(), srcMask->height());
 
-    drawState->addColorProcessor(
+    drawState->addCoverageProcessor(
         GrTextureDomainEffect::Create(srcMask,
                                       sampleM,
                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode))->unref();
+    // The color passed in here does not matter since the coverageSetOpXP won't read it.
     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;
 
@@ skipping 85 matching lines @@
     GrDrawTarget::AutoClipRestore acr(fClipTarget, maskSpaceIBounds);
     SkAutoTUnref<GrTexture> temp;
 
     // walk through each clip element and perform its set op
     for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             GrDrawState drawState(translate);
-            // We're drawing a coverage mask and want coverage to be run through the blend function.
-            drawState.enableState(GrDrawState::kCoverageDrawing_StateBit |
-                                  GrDrawState::kClip_StateBit);
+            drawState.enableState(GrDrawState::kClip_StateBit);
 
             GrPathRenderer* pr = NULL;
             bool useTemp = !this->canStencilAndDrawElement(&drawState, result, &pr, element);
             GrTexture* dst;
             // This is the bounds of the clip element in the space of the alpha-mask. The temporary
             // mask buffer can be substantially larger than the actually clip stack element. We
             // touch the minimum number of pixels necessary and use decal mode to combine it with
             // the accumulator.
             SkIRect maskSpaceElementIBounds;
 
@@ skipping 13 matching lines @@
                         fAACache.reset();
                         return NULL;
                     }
                 }
                 dst = temp;
                 // clear the temp target and set blend to replace
                 fClipTarget->clear(&maskSpaceElementIBounds,
                                    invert ? 0xffffffff : 0x00000000,
                                    true,
                                    dst->asRenderTarget());
-                setup_boolean_blendcoeffs(SkRegion::kReplace_Op, &drawState);
+                set_coverage_drawing_xpf(SkRegion::kReplace_Op, invert, &drawState);
             } else {
                 // draw directly into the result with the stencil set to make the pixels affected
                 // by the clip shape be non-zero.
                 dst = result;
                 GR_STATIC_CONST_SAME_STENCIL(kStencilInElement,
                                              kReplace_StencilOp,
                                              kReplace_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0xffff,
                                              0xffff);
                 drawState.setStencil(kStencilInElement);
-                setup_boolean_blendcoeffs(op, &drawState);
+                set_coverage_drawing_xpf(op, invert, &drawState);
             }
 
-            // We have to backup the drawstate because the drawElement call may call into
-            // renderers which consume it.
-            GrDrawState backupDrawState(drawState);
-
-            if (!this->drawElement(&drawState, invert ? GrColor_TRANS_BLACK :
-                                                        GrColor_WHITE, dst, element, pr)) {
+            if (!this->drawElement(&drawState, dst, element, pr)) {
                 fAACache.reset();
                 return NULL;
             }
 
+            GrDrawState backgroundDrawState(translate);
+            backgroundDrawState.enableState(GrDrawState::kClip_StateBit);
+            backgroundDrawState.setRenderTarget(result->asRenderTarget());
+
             if (useTemp) {
                 // Now draw into the accumulator using the real operation and the temp buffer as a
                 // texture
-                this->mergeMask(&backupDrawState,
+                this->mergeMask(&backgroundDrawState,
                                 result,
                                 temp,
                                 op,
                                 maskSpaceIBounds,
                                 maskSpaceElementIBounds);
             } else {
+                set_coverage_drawing_xpf(op, !invert, &backgroundDrawState);
                 // Draw to the exterior pixels (those with a zero stencil value).
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
-                backupDrawState.setStencil(kDrawOutsideElement);
-                fClipTarget->drawSimpleRect(&backupDrawState,
-                                            invert ? GrColor_WHITE : GrColor_TRANS_BLACK,
-                                            clipSpaceIBounds);
+                backgroundDrawState.setStencil(kDrawOutsideElement);
+                // The color passed in here does not matter since the coverageSetOpXP won't read it.
+                fClipTarget->drawSimpleRect(&backgroundDrawState, GrColor_WHITE, clipSpaceIBounds);
             }
         } else {
             GrDrawState drawState(translate);
-            drawState.enableState(GrDrawState::kCoverageDrawing_StateBit |
-                                  GrDrawState::kClip_StateBit);
+            drawState.enableState(GrDrawState::kClip_StateBit);
 
             // all the remaining ops can just be directly draw into the accumulation buffer
-            setup_boolean_blendcoeffs(op, &drawState);
-            this->drawElement(&drawState, GrColor_WHITE, result, element);
+            set_coverage_drawing_xpf(op, false, &drawState);
+            // The color passed in here does not matter since the coverageSetOpXP won't read it.
+            this->drawElement(&drawState, 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 408 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);
     }
 }