Pass bounds into draw calls in path renderers.

src/gpu/GrDefaultPathRenderer.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultPathRenderer.h"
 
@@ skipping 427 matching lines @@
                         }
                     }
                     break;
                 default:
                     GrAssert(!"Unknown path fFill!");
                     return false;
             }
         }
     }
 
-    {
+    SkRect devBounds;
+    GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
+
     for (int p = 0; p < passCount; ++p) {
         drawState->setDrawFace(drawFace[p]);
         if (NULL != passes[p]) {
             *drawState->stencil() = *passes[p];
         }
 
         if (lastPassIsBounds && (p == passCount-1)) {
             if (!colorWritesWereDisabled) {
                 drawState->disableState(GrDrawState::kNoColorWrites_StateBit);
             }
             GrRect bounds;
             GrDrawState::AutoDeviceCoordDraw adcd;
             if (reverse) {
                 GrAssert(NULL != drawState->getRenderTarget());
                 // draw over the whole world.

[robertphillips, 2013/05/16 13:14:45]

// GetPathDevBounds sets the bound to the device's full size for inverse filled
paths

[jvanverth1, 2013/05/16 13:20:04]

Change this comment?

[bsalomon, 2013/05/16 19:59:07]

Done.

[bsalomon, 2013/05/16 19:59:07]

Done.

-                bounds.setLTRB(0, 0,
-                               SkIntToScalar(drawState->getRenderTarget()->width()),
-                               SkIntToScalar(drawState->getRenderTarget()->height()));
+                bounds = devBounds;
                 SkMatrix vmi;
                 // mapRect through persp matrix may not be correct
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     adcd.set(drawState);
                 }
             } else {
                 bounds = path.getBounds();
             }
             GrDrawTarget::AutoGeometryAndStatePush agasp(target, GrDrawTarget::kPreserve_ASRInit);
             target->drawSimpleRect(bounds, NULL);
         } else {
             if (passCount > 1) {
                 drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
             }
             if (indexCnt) {
                 target->drawIndexed(primType, 0, 0,
-                                    vertexCnt, indexCnt);
+                                    vertexCnt, indexCnt, &devBounds);
             } else {
-                target->drawNonIndexed(primType, 0, vertexCnt);
+                target->drawNonIndexed(primType, 0, vertexCnt, &devBounds);
             }
         }
     }
-    }
     return true;
 }
 
 bool GrDefaultPathRenderer::canDrawPath(const SkPath& path,
                                         const SkStrokeRec& stroke,
                                         const GrDrawTarget* target,
                                         bool antiAlias) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
     return (stroke.isFillStyle() || stroke.isHairlineStyle()) && !antiAlias;
 }
 
 bool GrDefaultPathRenderer::onDrawPath(const SkPath& path,
                                        const SkStrokeRec& stroke,
                                        GrDrawTarget* target,
                                        bool antiAlias) {
     return this->internalDrawPath(path,
                                   stroke,
                                   target,
                                   false);
 }
 
 void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
                                           const SkStrokeRec& stroke,
                                           GrDrawTarget* target) {
     GrAssert(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     GrAssert(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(path, stroke, target, true);
 }