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);
@@ skipping 74 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

[bsalomon, 2014/12/16 17:35:56]

we do??

[egdaniel, 2014/12/17 21:12:37]

changed to false and changed to use coverageProcessor below. I manually checked
that we draw with the same set of bugs as we currently do for these temp paths.

+    set_coverage_drawing_xpf(op, true, drawState);
 
     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();
+    // 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)) {
+            // The color passed in here does not matter since the coverageSetOpXP won't read it.
+            if (!this->drawElement(&drawState, GrColor_WHITE, dst, element, pr)) {

[bsalomon, 2014/12/16 17:35:56]

Can drawElement just not take a color then?

[egdaniel, 2014/12/17 21:12:37]

Done.

                 fAACache.reset();
                 return NULL;
             }
 
+            // We have to make a new drawstate because the drawElement call may call into

[bsalomon, 2014/12/16 17:35:56]

I'm not sure this comment adds much value. A new drawstate for a new draw, seems
like we're justfying something that is self-explanatory/. It was the old
behavior that was weird/stateful.

[egdaniel, 2014/12/17 21:12:37]

removed

+            // renderers which consume it. We also need to use a different coverage drawing xp which
+            // inverts the coverage.
+            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);
+            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, GrColor_WHITE, result, element);
         }
     }
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
@@ skipping 409 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);
     }
 }