Drawstate on stack

src/gpu/effects/GrDashingEffect.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 "GrDashingEffect.h"
 
 #include "../GrAARectRenderer.h"
@@ skipping 11 matching lines @@
 #include "SkGr.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
 static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
-                               const GrDrawTarget& target, const SkMatrix& viewMatrix) {
-    if (target.getDrawState().getRenderTarget()->isMultisampled()) {
+                               const GrDrawTarget& target, const GrDrawState& ds,
+                               const SkMatrix& viewMatrix) {
+    if (ds.getRenderTarget()->isMultisampled()) {
         return false;
     }
 
     // Pts must be either horizontal or vertical in src space
     if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
         return false;
     }
 
     // May be able to relax this to include skew. As of now cannot do perspective
     // because of the non uniform scaling of bloating a rect
@@ skipping 119 matching lines @@
 
 static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& matrix,
                                   SkPoint* verts) {
     verts[idx] = SkPoint::Make(rect.fLeft, rect.fTop);
     verts[idx + 1] = SkPoint::Make(rect.fLeft, rect.fBottom);
     verts[idx + 2] = SkPoint::Make(rect.fRight, rect.fBottom);
     verts[idx + 3] = SkPoint::Make(rect.fRight, rect.fTop);
     matrix.mapPoints(&verts[idx], 4);
 }
 
-bool GrDashingEffect::DrawDashLine(const SkPoint pts[2], const GrPaint& paint,
-                                   const GrStrokeInfo& strokeInfo, GrGpu* gpu,
-                                   GrDrawTarget* target, const SkMatrix& vm) {
+bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState* drawState,
+                                   const SkPoint pts[2], const GrPaint& paint,
+                                   const GrStrokeInfo& strokeInfo, const SkMatrix& vm) {
 
-    if (!can_fast_path_dash(pts, strokeInfo, *target, vm)) {
+    if (!can_fast_path_dash(pts, strokeInfo, *target, *drawState, vm)) {
         return false;
     }
 
     const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
 
     SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
 
     SkScalar srcStrokeWidth = strokeInfo.getStrokeRec().getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
@@ skipping 124 matching lines @@
         devIntervals[0] += strokeWidth;
         devIntervals[1] -= strokeWidth;
     }
     SkScalar startOffset = devIntervals[1] * 0.5f + devPhase;
 
     SkScalar bloatX = useAA ? 0.5f / parallelScale : 0.f;
     SkScalar bloatY = useAA ? 0.5f / perpScale : 0.f;
 
     SkScalar devBloat = useAA ? 0.5f : 0.f;
 
-    GrDrawState* drawState = target->drawState();
     if (devIntervals[1] <= 0.f && useAA) {
         // Case when we end up drawing a solid AA rect
         // Reset the start rect to draw this single solid rect
         // but it requires to upload a new intervals uniform so we can mimic
         // one giant dash
         ptsRot[0].fX -= hasStartRect ? startAdj : 0;
         ptsRot[1].fX += hasEndRect ? endAdj : 0;
         startRect.set(ptsRot, 2);
         startRect.outset(strokeAdj, halfSrcStroke);
         hasStartRect = true;
@@ skipping 32 matching lines @@
                         drawState,
                         GrDefaultGeoProcFactory::kPosition_GPType))->unref();
     }
 
     int totalRectCnt = 0;
 
     totalRectCnt += !lineDone ? 1 : 0;
     totalRectCnt += hasStartRect ? 1 : 0;
     totalRectCnt += hasEndRect ? 1 : 0;
 
-    GrDrawTarget::AutoReleaseGeometry geo(target, totalRectCnt * 4, 0);
+    GrDrawTarget::AutoReleaseGeometry geo(target,
+                                          totalRectCnt * 4,
+                                          drawState->getVertexStride(), 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     int curVIdx = 0;
 
     if (SkPaint::kRound_Cap == cap && 0 != srcStrokeWidth) {
         // need to adjust this for round caps to correctly set the dashPos attrib on vertices
         startOffset -= halfDevStroke;
@@ skipping 45 matching lines @@
             setup_dashed_rect(endRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
                               devIntervals[0], halfDevStroke);
         } else {
             SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
             setup_dashed_rect_pos(endRect, curVIdx, combinedMatrix, verts);
         }
 
     }
 
     target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
-    target->drawIndexedInstances(kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
+    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
     target->resetIndexSource();
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
 /*
  * This effect will draw a dotted line (defined as a dashed lined with round caps and no on
  * interval). The radius of the dots is given by the strokeWidth and the spacing by the DashInfo.
@@ skipping 420 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }