Drawstate on stack

src/gpu/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 47 matching lines @@
     }
     
     SkDELETE(fAtlas);
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool GrAADistanceFieldPathRenderer::canDrawPath(const SkPath& path,
+bool GrAADistanceFieldPathRenderer::canDrawPath(const GrDrawTarget* target,
+                                                const GrDrawState* drawState,
+                                                const SkPath& path,
                                                 const SkStrokeRec& stroke,
-                                                const GrDrawTarget* target,
                                                 bool antiAlias) const {
     
     // TODO: Support inverse fill
     // TODO: Support strokes
     if (!target->caps()->shaderDerivativeSupport() || !antiAlias || path.isInverseFillType()
         || path.isVolatile() || SkStrokeRec::kFill_Style != stroke.getStyle()) {
         return false;
     }
 
     // currently don't support perspective
-    const GrDrawState& drawState = target->getDrawState();
-    const SkMatrix& vm = drawState.getViewMatrix();
+    const SkMatrix& vm = drawState->getViewMatrix();
     if (vm.hasPerspective()) {
         return false;
     }
     
     // only support paths smaller than 64x64, scaled to less than 256x256
     // the goal is to accelerate rendering of lots of small paths that may be scaling
     SkScalar maxScale = vm.getMaxScale();
     const SkRect& bounds = path.getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     return maxDim < 64.f && maxDim*maxScale < 256.f;
 }
 
 
-GrPathRenderer::StencilSupport GrAADistanceFieldPathRenderer::onGetStencilSupport(
-                                                                       const SkPath&,
-                                                                       const SkStrokeRec&,
-                                                                       const GrDrawTarget*) const {
+GrPathRenderer::StencilSupport
+GrAADistanceFieldPathRenderer::onGetStencilSupport(const GrDrawTarget*,
+                                                   const GrDrawState*,
+                                                   const SkPath&,
+                                                   const SkStrokeRec&) const {
     return GrPathRenderer::kNoSupport_StencilSupport;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // position + texture coord
 extern const GrVertexAttrib gSDFPathVertexAttribs[] = {
     { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding },
     { kVec2f_GrVertexAttribType, sizeof(SkPoint), kGeometryProcessor_GrVertexAttribBinding }
 };
 static const size_t kSDFPathVASize = 2 * sizeof(SkPoint);
 
-bool GrAADistanceFieldPathRenderer::onDrawPath(const SkPath& path,
+bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target,
+                                               GrDrawState* drawState,
+                                               const SkPath& path,
                                                const SkStrokeRec& stroke,
-                                               GrDrawTarget* target,
                                                bool antiAlias) {
     // we've already bailed on inverse filled paths, so this is safe
     if (path.isEmpty()) {
         return true;
     }
 
     SkASSERT(fContext);
 
     // get mip level
-    const GrDrawState& drawState = target->getDrawState();
-    const SkMatrix& vm = drawState.getViewMatrix();
+    const SkMatrix& vm = drawState->getViewMatrix();
     SkScalar maxScale = vm.getMaxScale();
     const SkRect& bounds = path.getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     SkScalar size = maxScale*maxDim;
     uint32_t desiredDimension;
     if (size <= kSmallMIP) {
         desiredDimension = kSmallMIP;
     } else if (size <= kMediumMIP) {
         desiredDimension = kMediumMIP;
     } else {
         desiredDimension = kLargeMIP;
     }
 
     // check to see if path is cached
     // TODO: handle stroked vs. filled version of same path
     PathData::Key key = { path.getGenerationID(), desiredDimension };
     PathData* pathData = fPathCache.find(key);
     if (NULL == pathData) {
         SkScalar scale = desiredDimension/maxDim;
         pathData = this->addPathToAtlas(path, stroke, antiAlias, desiredDimension, scale);
         if (NULL == pathData) {
             return false;
         }
     }
 
     // use signed distance field to render
-    return this->internalDrawPath(path, pathData, target);
+    return this->internalDrawPath(target, drawState, path, pathData);
 }
 
 // padding around path bounds to allow for antialiased pixels
 const SkScalar kAntiAliasPad = 1.0f;
 
 GrAADistanceFieldPathRenderer::PathData* GrAADistanceFieldPathRenderer::addPathToAtlas(
                                                                         const SkPath& path,
                                                                         const SkStrokeRec& stroke,
                                                                         bool antiAlias,
                                                                         uint32_t dimension,
@@ skipping 140 matching lines @@
 #endif
         }
     }
         
     // tell the atlas to free the plot
     GrAtlas::RemovePlot(&fPlotUsage, plot);
     
     return true;
 }
 
-bool GrAADistanceFieldPathRenderer::internalDrawPath(const SkPath& path,
-                                                     const PathData* pathData,
-                                                     GrDrawTarget* target) {
+bool GrAADistanceFieldPathRenderer::internalDrawPath(GrDrawTarget* target,
+                                                     GrDrawState* drawState,
+                                                     const SkPath& path,
+                                                     const PathData* pathData) {
     GrTexture* texture = fAtlas->getTexture();
-    GrDrawState* drawState = target->drawState();
     GrDrawState::AutoRestoreEffects are(drawState);
     
     SkASSERT(pathData->fPlot);
     GrDrawTarget::DrawToken drawToken = target->getCurrentDrawToken();
     pathData->fPlot->setDrawToken(drawToken);
     
     // make me some vertices
     drawState->setVertexAttribs<gSDFPathVertexAttribs>(SK_ARRAY_COUNT(gSDFPathVertexAttribs),
                                                        kSDFPathVASize);
     void* vertices = NULL;
-    bool success = target->reserveVertexAndIndexSpace(4, 0, &vertices, NULL);
+    bool success = target->reserveVertexAndIndexSpace(4, drawState->getVertexStride(), 0, &vertices,
+                                                      NULL);
     GrAlwaysAssert(success);
     
     SkScalar dx = pathData->fBounds.fLeft;
     SkScalar dy = pathData->fBounds.fTop;
     SkScalar width = pathData->fBounds.width();
     SkScalar height = pathData->fBounds.height();
     
     SkScalar invScale = 1.0f/pathData->fScale;
     dx *= invScale;
     dy *= invScale;
@@ skipping 29 matching lines @@
     if (flags != fEffectFlags) {
         fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(texture,
                                                                                    params,
                                                                                    flags));
         fEffectFlags = flags;
     }
     drawState->setGeometryProcessor(fCachedGeometryProcessor.get());
 
     vm.mapRect(&r);
     target->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
-    target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6, &r);
+    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &r);
     target->resetVertexSource();
     
     return true;
 }