Drawstate on stack

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"
 
 #include "GrContext.h"
@@ skipping 145 matching lines @@
 #if STENCIL_OFF
     return true;
 #else
     if (!stroke.isHairlineStyle() && !path.isInverseFillType()) {
         return path.isConvex();
     }
     return false;
 #endif
 }
 
-GrPathRenderer::StencilSupport GrDefaultPathRenderer::onGetStencilSupport(
-                                                            const SkPath& path,
-                                                            const SkStrokeRec& stroke,
-                                                            const GrDrawTarget*) const {
+GrPathRenderer::StencilSupport
+GrDefaultPathRenderer::onGetStencilSupport(const GrDrawTarget*,
+                                           const GrDrawState*,
+                                           const SkPath& path,
+                                           const SkStrokeRec& stroke) const {
     if (single_pass_path(path, stroke)) {
         return GrPathRenderer::kNoRestriction_StencilSupport;
     } else {
         return GrPathRenderer::kStencilOnly_StencilSupport;
     }
 }
 
 static inline void append_countour_edge_indices(bool hairLine,
                                                 uint16_t fanCenterIdx,
                                                 uint16_t edgeV0Idx,
                                                 uint16_t** indices) {
     // when drawing lines we're appending line segments along
     // the contour. When applying the other fill rules we're
     // drawing triangle fans around fanCenterIdx.
     if (!hairLine) {
         *((*indices)++) = fanCenterIdx;
     }
     *((*indices)++) = edgeV0Idx;
     *((*indices)++) = edgeV0Idx + 1;
 }
 
-bool GrDefaultPathRenderer::createGeom(const SkPath& path,
-                                       const SkStrokeRec& stroke,
-                                       SkScalar srcSpaceTol,
-                                       GrDrawTarget* target,
+bool GrDefaultPathRenderer::createGeom(GrDrawTarget* target,
+                                       GrDrawState* drawState,
                                        GrPrimitiveType* primType,
                                        int* vertexCnt,
                                        int* indexCnt,
-                                       GrDrawTarget::AutoReleaseGeometry* arg) {
+                                       GrDrawTarget::AutoReleaseGeometry* arg,
+                                       const SkPath& path,
+                                       const SkStrokeRec& stroke,
+                                       SkScalar srcSpaceTol) {
     {
     SkScalar srcSpaceTolSqd = SkScalarMul(srcSpaceTol, srcSpaceTol);
     int contourCnt;
     int maxPts = GrPathUtils::worstCasePointCount(path, &contourCnt,
                                                   srcSpaceTol);
 
     if (maxPts <= 0) {
         return false;
     }
     if (maxPts > ((int)SK_MaxU16 + 1)) {
@@ skipping 15 matching lines @@
         }
     } else {
         if (indexed) {
             maxIdxs = 3 * maxPts;
             *primType = kTriangles_GrPrimitiveType;
         } else {
             *primType = kTriangleFan_GrPrimitiveType;
         }
     }
 
-    target->drawState()->setDefaultVertexAttribs();
-    if (!arg->set(target, maxPts, maxIdxs)) {
+    drawState->setDefaultVertexAttribs();
+    if (!arg->set(target, maxPts, drawState->getVertexStride(), maxIdxs)) {
         return false;
     }
 
     uint16_t* idxBase = reinterpret_cast<uint16_t*>(arg->indices());
     uint16_t* idx = idxBase;
     uint16_t subpathIdxStart = 0;
 
     SkPoint* base = reinterpret_cast<SkPoint*>(arg->vertices());
     SkASSERT(base);
     SkPoint* vert = base;
@@ skipping 71 matching lines @@
     SkASSERT((vert - base) <= maxPts);
     SkASSERT((idx - idxBase) <= maxIdxs);
 
     *vertexCnt = static_cast<int>(vert - base);
     *indexCnt = static_cast<int>(idx - idxBase);
 
     }
     return true;
 }
 
-bool GrDefaultPathRenderer::internalDrawPath(const SkPath& path,
+bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target,
+                                             GrDrawState* drawState,
+                                             const SkPath& path,
                                              const SkStrokeRec& origStroke,
-                                             GrDrawTarget* target,
                                              bool stencilOnly) {
-
-    SkMatrix viewM = target->getDrawState().getViewMatrix();
+    SkMatrix viewM = drawState->getViewMatrix();
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
 
     SkScalar hairlineCoverage;
-    if (IsStrokeHairlineOrEquivalent(*stroke, target->getDrawState().getViewMatrix(),
+    if (IsStrokeHairlineOrEquivalent(*stroke, drawState->getViewMatrix(),
                                      &hairlineCoverage)) {
-        uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage *
-                                                 target->getDrawState().getCoverage());
-        target->drawState()->setCoverage(newCoverage);
+        uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage * drawState->getCoverage());
+        drawState->setCoverage(newCoverage);
 
         if (!stroke->isHairlineStyle()) {
             stroke.writable()->setHairlineStyle();
         }
     }
 
     SkScalar tol = SK_Scalar1;
     tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, path.getBounds());
 
     int vertexCnt;
     int indexCnt;
     GrPrimitiveType primType;
     GrDrawTarget::AutoReleaseGeometry arg;
-    if (!this->createGeom(path,
-                          *stroke,
-                          tol,
-                          target,
+    if (!this->createGeom(target,
+                          drawState,
                           &primType,
                           &vertexCnt,
                           &indexCnt,
-                          &arg)) {
+                          &arg,
+                          path,
+                          *stroke,
+                          tol)) {
         return false;
     }
 
-    SkASSERT(target);
-    GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
-    GrDrawState* drawState = target->drawState();
     bool colorWritesWereDisabled = drawState->isColorWriteDisabled();
     // face culling doesn't make sense here
     SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
 
     int                         passCount = 0;
     const GrStencilSettings*    passes[3];
     GrDrawState::DrawFace       drawFace[3];
     bool                        reverse = false;
     bool                        lastPassIsBounds;
 
@@ skipping 106 matching lines @@
                 // mapRect through persp matrix may not be correct
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     avmr.setIdentity(drawState);
                 }
             } else {
                 bounds = path.getBounds();
             }
-            GrDrawTarget::AutoGeometryAndStatePush agasp(target, GrDrawTarget::kPreserve_ASRInit);
-            target->drawSimpleRect(bounds);
+            GrDrawTarget::AutoGeometryPush agp(target);
+            target->drawSimpleRect(drawState, bounds);
         } else {
             if (passCount > 1) {
                 drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
             }
             GrDrawState::AutoRestoreEffects are(drawState);
             drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(false))->unref();
             if (indexCnt) {
-                target->drawIndexed(primType, 0, 0,
-                                    vertexCnt, indexCnt, &devBounds);
+                target->drawIndexed(drawState,
+                                    primType,
+                                    0,
+                                    0,
+                                    vertexCnt,
+                                    indexCnt,
+                                    &devBounds);
             } else {
-                target->drawNonIndexed(primType, 0, vertexCnt, &devBounds);
+                target->drawNonIndexed(drawState, primType, 0, vertexCnt, &devBounds);
             }
         }
     }
     return true;
 }
 
-bool GrDefaultPathRenderer::canDrawPath(const SkPath& path,
+bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget* target,
+                                        const GrDrawState* drawState,
+                                        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 !antiAlias && !(SkPath::kConic_SegmentMask & path.getSegmentMasks()) &&
         (stroke.isFillStyle() ||
-         IsStrokeHairlineOrEquivalent(stroke, target->getDrawState().getViewMatrix(), NULL));
+         IsStrokeHairlineOrEquivalent(stroke, drawState->getViewMatrix(), NULL));
 }
 
-bool GrDefaultPathRenderer::onDrawPath(const SkPath& path,
+bool GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target,
+                                       GrDrawState* drawState,
+                                       const SkPath& path,
                                        const SkStrokeRec& stroke,
-                                       GrDrawTarget* target,
                                        bool antiAlias) {
-    return this->internalDrawPath(path,
+    return this->internalDrawPath(target,
+                                  drawState,
+                                  path,
                                   stroke,
-                                  target,
                                   false);
 }
 
-void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
-                                          const SkStrokeRec& stroke,
-                                          GrDrawTarget* target) {
+void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
+                                          GrDrawState* drawState,
+                                          const SkPath& path,
+                                          const SkStrokeRec& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
-    this->internalDrawPath(path, stroke, target, true);
+    this->internalDrawPath(target, drawState, path, stroke, true);
 }