Stateful PathRenderer implementation

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"
@@ skipping 12 matching lines @@
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 
 #define GR_AA_CLIP 1
 
 typedef SkClipStack::Element Element;
 
 using namespace GrReducedClip;
 
 ////////////////////////////////////////////////////////////////////////////////
-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,
-                            GrTexture* result,
-                            const SkIRect &devBound) {
+static void setup_drawstate_aaclip(GrGpu* gpu,
+                                   GrTexture* result,
+                                   const SkIRect &devBound) {
     GrDrawState* drawState = gpu->drawState();
     SkASSERT(drawState);
 
     SkMatrix mat;
     // We want to use device coords to compute the texture coordinates. We set our matrix to be
     // equal to the view matrix followed by an offset to the devBound, and then a scaling matrix to
     // normalized coords. We apply this matrix to the vertex positions rather than local coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
     mat.preConcat(drawState->getViewMatrix());
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     // This could be a long-lived effect that is cached with the alpha-mask.
     drawState->addCoverageEffect(
         GrTextureDomainEffect::Create(result,
                                       mat,
                                       GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode,
                                       kPosition_GrCoordSet))->unref();
 }
 
-bool path_needs_SW_renderer(GrContext* context,
-                            GrGpu* gpu,
-                            const SkPath& origPath,
-                            const SkStrokeRec& stroke,
-                            bool doAA) {
-    // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
-    SkTCopyOnFirstWrite<SkPath> path(origPath);
-    if (path->isInverseFillType()) {
-        path.writable()->toggleInverseFillType();
-    }
-    // last (false) parameter disallows use of the SW path renderer
+static bool path_needs_SW_renderer(GrContext* context,
+                                   GrGpu* gpu,
+                                   const SkPath& origPath,
+                                   const SkStrokeRec& stroke,
+                                   bool doAA) {
     GrPathRendererChain::DrawType type = doAA ?
                                          GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
+    // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
+    SkPath::FillType fillType = SkPath::ConvertToNonInverseFillType(origPath.getFillType());
 
-    return NULL == context->getPathRenderer(*path, stroke, gpu, false, type);
-}
-
+    // the 'false' parameter disallows use of the SW path renderer
+    GrPathRenderer::AutoClearPath acp(context->getPathRenderer(origPath, stroke, gpu, 
+                                                               false, type, fillType));
+    return NULL == acp.renderer();
 }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
 bool GrClipMaskManager::useSWOnlyPath(const ElementList& elements) {
 
     // TODO: generalize this function so that when
@@ skipping 216 matching lines @@
             break;
         default:
             SkASSERT(false);
             break;
     }
 }
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool GrClipMaskManager::drawElement(GrTexture* target,
-                                    const SkClipStack::Element* element,
-                                    GrPathRenderer* pr) {
+bool GrClipMaskManager::drawFilledPath(GrTexture* target,
+                                       GrPathRenderer* pathRenderer, 
+                                       bool isAA) {
     GrDrawState* drawState = fGpu->drawState();
 
     drawState->setRenderTarget(target->asRenderTarget());
+
+    SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
+    pathRenderer->drawPath(stroke, fGpu, isAA);
+    return true;
+}
+
+bool GrClipMaskManager::drawElement(GrTexture* target,
+                                    const SkClipStack::Element* element) {
+    GrDrawState* drawState = fGpu->drawState();
+
+    drawState->setRenderTarget(target->asRenderTarget());
 
     switch (element->getType()) {
         case Element::kRect_Type:
             // TODO: Do rects directly to the accumulator using a aa-rect GrEffect 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(),
                                                               false);
             } else {
                 fGpu->drawSimpleRect(element->getRect(), NULL);
             }
             return true;
         case Element::kPath_Type: {
-            SkTCopyOnFirstWrite<SkPath> path(element->getPath());
-            if (path->isInverseFillType()) {
-                path.writable()->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(*path, stroke, fGpu, false, type);
-            }
-            if (NULL == pr) {
+            GrPathRendererChain::DrawType type;
+            type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
+                                     GrPathRendererChain::kColor_DrawType;
+            SkPath::FillType fillType = element->getPath().getFillType();
+            GrPathRenderer::AutoClearPath acp(this->getContext()->getPathRenderer(
+                                                  element->getPath(), 
+                                                  stroke, fGpu, false, type,
+                                                  SkPath::ConvertToNonInverseFillType(fillType)));
+            if (NULL == acp.renderer()) {
                 return false;
             }
-            pr->drawPath(element->getPath(), stroke, fGpu, element->isAA());
+            acp->drawPath(stroke, fGpu, element->isAA());
             break;
         }
         default:
             // something is wrong if we're trying to draw an empty element.
             GrCrash("Unexpected element type");
             return false;
     }
     return true;
 }
 
 bool GrClipMaskManager::canStencilAndDrawElement(GrTexture* target,
                                                  const SkClipStack::Element* element,
-                                                 GrPathRenderer** pr) {
+                                                 GrPathRenderer::AutoClearPath* acp) {
     GrDrawState* drawState = fGpu->drawState();
     drawState->setRenderTarget(target->asRenderTarget());
 
     switch (element->getType()) {
         case Element::kRect_Type:
             return true;
         case Element::kPath_Type: {
-            SkTCopyOnFirstWrite<SkPath> path(element->getPath());
-            if (path->isInverseFillType()) {
-                path.writable()->toggleInverseFillType();
-            }
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
             GrPathRendererChain::DrawType type = element->isAA() ?
                 GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
                 GrPathRendererChain::kStencilAndColor_DrawType;
-            *pr = this->getContext()->getPathRenderer(*path, stroke, fGpu, false, type);
-            return NULL != *pr;
+            SkPath::FillType fillType = element->getPath().getFillType();
+            acp->set(this->getContext()->getPathRenderer(element->getPath(), 
+                                                   stroke, fGpu, false, type,
+                                                   SkPath::ConvertToNonInverseFillType(fillType)));   
+            return NULL != acp->renderer();
         }
         default:
             // something is wrong if we're trying to draw an empty element.
             GrCrash("Unexpected element type");
             return false;
     }
 }
 
 void GrClipMaskManager::mergeMask(GrTexture* dstMask,
                                   GrTexture* srcMask,
@@ skipping 124 matching lines @@
     drawState->enableState(GrDrawState::kClip_StateBit);
 
     GrAutoScratchTexture temp;
     // walk through each clip element and perform its set op
     for (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) {
-            GrPathRenderer* pr = NULL;
-            bool useTemp = !this->canStencilAndDrawElement(result, element, &pr);
+            GrPathRenderer::AutoClearPath acp;
+            bool useTemp = !this->canStencilAndDrawElement(result, element, &acp);
             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;
 
             if (useTemp) {
                 if (invert) {
                     maskSpaceElementIBounds = maskSpaceIBounds;
@@ skipping 26 matching lines @@
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0xffff,
                                              0xffff);
                 drawState->setStencil(kStencilInElement);
                 setup_boolean_blendcoeffs(drawState, op);
             }
 
             drawState->setAlpha(invert ? 0x00 : 0xff);
 
-            if (!this->drawElement(dst, element, pr)) {
-                fAACache.reset();
-                return NULL;
+            if (NULL != acp.renderer()) {
+                this->drawFilledPath(dst, acp.renderer(), element->isAA());
+            } else {
+                if (!this->drawElement(dst, element)) {
+                    fAACache.reset();
+                    return NULL;
+                }
             }
 
             if (useTemp) {
                 // Now draw into the accumulator using the real operation and the temp buffer as a
                 // texture
                 this->mergeMask(result,
                                 temp.texture(),
                                 op,
                                 maskSpaceIBounds,
                                 maskSpaceElementIBounds);
             } else {
                 // Draw to the exterior pixels (those with a zero stencil value).
                 drawState->setAlpha(invert ? 0xff : 0x00);
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 drawState->setStencil(kDrawOutsideElement);
                 fGpu->drawSimpleRect(clipSpaceIBounds);
                 drawState->disableStencil();
             }
         } else {
-            // all the remaining ops can just be directly draw into the accumulation buffer
+            // all the remaining ops can just be directly drawn into the accumulation buffer
             drawState->setAlpha(0xff);
             setup_boolean_blendcoeffs(drawState, op);
             this->drawElement(result, element);
         }
     }
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
@@ skipping 65 matching lines @@
             }
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
 
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 
             SkRegion::Op op = element->getOp();
 
-            GrPathRenderer* pr = NULL;
-            SkTCopyOnFirstWrite<SkPath> clipPath;
+            GrPathRenderer::AutoClearPath acp;
             if (Element::kRect_Type == element->getType()) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
                 SkASSERT(Element::kPath_Type == element->getType());
-                clipPath.init(element->getPath());
-                fillInverted = clipPath->isInverseFillType();
-                if (fillInverted) {
-                    clipPath.writable()->toggleInverseFillType();
-                }
-                pr = this->getContext()->getPathRenderer(*clipPath,
+                fillInverted = element->getPath().isInverseFillType();
+                SkPath::FillType fill = element->getPath().getFillType();
+                acp.set(this->getContext()->getPathRenderer(element->getPath(),
                                                          stroke,
                                                          fGpu,
                                                          false,
                                                          GrPathRendererChain::kStencilOnly_DrawType,
-                                                         &stencilSupport);
-                if (NULL == pr) {
+                                                         SkPath::ConvertToNonInverseFillType(fill),
+                                                         &stencilSupport));
+                if (NULL == acp.renderer()) {
                     return false;
                 }
             }
 
             int passes;
             GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
 
             bool canRenderDirectToStencil =
                 GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport;
             bool canDrawDirectToClip; // Given the renderer, the element,
@@ skipping 15 matching lines @@
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 SET_RANDOM_COLOR
                 if (Element::kRect_Type == element->getType()) {
                     *drawState->stencil() = gDrawToStencil;
                     fGpu->drawSimpleRect(element->getRect(), NULL);
                 } else {
                     SkASSERT(Element::kPath_Type == element->getType());
-                    if (!clipPath->isEmpty()) {
+                    if (NULL != acp.renderer()) {
                         if (canRenderDirectToStencil) {
                             *drawState->stencil() = gDrawToStencil;
-                            pr->drawPath(*clipPath, stroke, fGpu, false);
+                            acp->drawPath(stroke, fGpu, false);
                         } else {
-                            pr->stencilPath(*clipPath, stroke, fGpu);
+                            acp->stencilPath(stroke, fGpu);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             drawState->enableState(GrGpu::kModifyStencilClip_StateBit);
             for (int p = 0; p < passes; ++p) {
                 *drawState->stencil() = stencilSettings[p];
                 if (canDrawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
                         SET_RANDOM_COLOR
                         fGpu->drawSimpleRect(element->getRect(), NULL);
                     } else {
                         SkASSERT(Element::kPath_Type == element->getType());
                         SET_RANDOM_COLOR
-                        pr->drawPath(*clipPath, stroke, fGpu, false);
+                        acp->drawPath(stroke, fGpu, false);
                     }
                 } else {
                     SET_RANDOM_COLOR
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
                     fGpu->drawSimpleRect(SkRect::Make(clipSpaceIBounds), NULL);
                 }
             }
         }
     }
@@ skipping 301 matching lines @@
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
     GrStencilBuffer* stencilBuffer =
         drawState.getRenderTarget()->getStencilBuffer();
     if (NULL != stencilBuffer) {
         stencilBits = stencilBuffer->bits();
         this->adjustStencilParams(settings, clipMode, stencilBits);
     }
 }