Move ViewMatrix off of drawstate

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 147 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(GrGpu* gpu, GrDrawTarget* target, GrDrawState* drawState,
-                                   GrColor color, const SkPoint pts[2], const GrPaint& paint,
-                                   const GrStrokeInfo& strokeInfo) {
-    const SkMatrix& vm = drawState->getViewMatrix();
-
-    if (!can_fast_path_dash(pts, strokeInfo, *target, *drawState, vm)) {
+                                   GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
+                                   const GrPaint& paint, const GrStrokeInfo& strokeInfo) {
+    if (!can_fast_path_dash(pts, strokeInfo, *target, *drawState, viewMatrix)) {
         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 14 matching lines @@
     } else {
         srcRotInv.reset();
         memcpy(ptsRot, pts, 2 * sizeof(SkPoint));
     }
 
     bool useAA = paint.isAntiAlias();
 
     // Scale corrections of intervals and stroke from view matrix
     SkScalar parallelScale;
     SkScalar perpScale;
-    calc_dash_scaling(&parallelScale, &perpScale, vm, ptsRot);
+    calc_dash_scaling(&parallelScale, &perpScale, viewMatrix, ptsRot);
 
     bool hasCap = SkPaint::kButt_Cap != cap && 0 != srcStrokeWidth;
 
     // We always want to at least stroke out half a pixel on each side in device space
     // so 0.5f / perpScale gives us this min in src space
     SkScalar halfSrcStroke = SkMaxScalar(srcStrokeWidth * 0.5f, 0.5f / perpScale);
 
     SkScalar strokeAdj;
     if (!hasCap) {
         strokeAdj = 0.f;
     } else {
         strokeAdj = halfSrcStroke;
     }
 
     SkScalar startAdj = 0;
 
     SkMatrix combinedMatrix = srcRotInv;
-    combinedMatrix.postConcat(vm);
+    combinedMatrix.postConcat(viewMatrix);
 
     bool lineDone = false;
     SkRect startRect;
     bool hasStartRect = false;
     // If we are using AA, check to see if we are drawing a partial dash at the start. If so
     // draw it separately here and adjust our start point accordingly
     if (useAA) {
         if (srcPhase > 0 && srcPhase < info.fIntervals[0]) {
             SkPoint startPts[2];
             startPts[0] = ptsRot[0];
@@ skipping 85 matching lines @@
         // 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;
         hasEndRect = false;
         lineDone = true;
 
         SkPoint devicePts[2];
-        vm.mapPoints(devicePts, ptsRot, 2);
+        viewMatrix.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
         devIntervals[0] = lineLength;
     }
 
     // reset to device coordinates
     SkMatrix invert;
-    if (!vm.invert(&invert)) {
+    if (!viewMatrix.invert(&invert)) {
         SkDebugf("Failed to invert\n");
         return false;
     }
 
-    GrDrawState::AutoViewMatrixRestore avmr(drawState);
-
     SkAutoTUnref<const GrGeometryProcessor> gp;
     bool fullDash = devIntervals[1] > 0.f || useAA;
     if (fullDash) {
         SkPathEffect::DashInfo devInfo;
         devInfo.fPhase = devPhase;
         devInfo.fCount = 2;
         devInfo.fIntervals = devIntervals;
         GrPrimitiveEdgeType edgeType= useAA ? kFillAA_GrProcessorEdgeType :
             kFillBW_GrProcessorEdgeType;
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
                                                         GrDashingEffect::kNonRound_DashCap;
         gp.reset(GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType, invert));
     } else {
         // Set up the vertex data for the line and start/end dashes
-        gp.reset(GrDefaultGeoProcFactory::Create(color, GrDefaultGeoProcFactory::kPosition_GPType,
+        gp.reset(GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
+                                                 color,
+                                                 SkMatrix::I(),
                                                  invert));
     }
 
     int totalRectCnt = 0;
 
     totalRectCnt += !lineDone ? 1 : 0;
     totalRectCnt += hasStartRect ? 1 : 0;
     totalRectCnt += hasEndRect ? 1 : 0;
 
     GrDrawTarget::AutoReleaseGeometry geo(target,
                                           totalRectCnt * 4,
                                           gp->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;
     }
 
     // Draw interior part of dashed line
     if (!lineDone) {
         SkPoint devicePts[2];
-        vm.mapPoints(devicePts, ptsRot, 2);
+        viewMatrix.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
 
         SkRect bounds;
         bounds.set(ptsRot[0].fX, ptsRot[0].fY, ptsRot[1].fX, ptsRot[1].fY);
         bounds.outset(bloatX + strokeAdj, bloatY + halfSrcStroke);
         if (fullDash) {
             DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
@@ skipping 266 matching lines @@
 
 GrGLGeometryProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt));
 }
 
 DashingCircleEffect::DashingCircleEffect(GrColor color,
                                          GrPrimitiveEdgeType edgeType,
                                          const DashInfo& info,
                                          SkScalar radius,
                                          const SkMatrix& localMatrix)
-    : INHERITED(color, false, localMatrix), fEdgeType(edgeType) {
+    : INHERITED(color, SkMatrix::I(), localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     fIntervalLength = onLen + offLen;
     fRadius = radius;
     fCenterX = SkScalarHalf(offLen);
 }
 
@@ skipping 32 matching lines @@
             kGrProcessorEdgeTypeCnt));
     SkScalar strokeWidth = random->nextRangeScalar(0, 100.f);
     DashInfo info;
     info.fCount = 2;
     SkAutoTArray<SkScalar> intervals(info.fCount);
     info.fIntervals = intervals.get();
     info.fIntervals[0] = 0; 
     info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
     info.fPhase = random->nextRangeScalar(0, info.fIntervals[1]);
 
-    return DashingCircleEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth,
+    return DashingCircleEffect::Create(GrRandomColor(random),
+                                       edgeType, info, strokeWidth,
                                        GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect;
 
 struct DashingLineBatchTracker {
     GrGPInput fInputColorType;
     GrColor  fColor;
@@ skipping 220 matching lines @@
 
 GrGLGeometryProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GLDashingLineEffect, (*this, bt));
 }
 
 DashingLineEffect::DashingLineEffect(GrColor color,
                                      GrPrimitiveEdgeType edgeType,
                                      const DashInfo& info,
                                      SkScalar strokeWidth,
                                      const SkMatrix& localMatrix)
-    : INHERITED(color, false, localMatrix), fEdgeType(edgeType) {
+    : INHERITED(color, SkMatrix::I(), localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     SkScalar halfOffLen = SkScalarHalf(offLen);
     SkScalar halfStroke = SkScalarHalf(strokeWidth);
     fIntervalLength = onLen + offLen;
     fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke);
 }
@@ skipping 32 matching lines @@
             kGrProcessorEdgeTypeCnt));
     SkScalar strokeWidth = random->nextRangeScalar(0, 100.f);
     DashInfo info;
     info.fCount = 2;
     SkAutoTArray<SkScalar> intervals(info.fCount);
     info.fIntervals = intervals.get();
     info.fIntervals[0] = random->nextRangeScalar(0, 10.f);
     info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
     info.fPhase = random->nextRangeScalar(0, info.fIntervals[0] + info.fIntervals[1]);
 
-    return DashingLineEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth,
+    return DashingLineEffect::Create(GrRandomColor(random),
+                                     edgeType, info, strokeWidth,
                                      GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* GrDashingEffect::Create(GrColor color,
                                              GrPrimitiveEdgeType edgeType,
                                              const SkPathEffect::DashInfo& info,
                                              SkScalar strokeWidth,
                                              GrDashingEffect::DashCap cap,
                                              const SkMatrix& localMatrix) {
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
-            return DashingCircleEffect::Create(color, edgeType, info, SkScalarHalf(strokeWidth),
+            return DashingCircleEffect::Create(color, edgeType, info,
+                                               SkScalarHalf(strokeWidth),
                                                localMatrix);
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(color, edgeType, info, strokeWidth, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }