Move ViewMatrix off of drawstate

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 626 matching lines @@
 
     *vert += kLineSegNumVertices;
 }
 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAHairLinePathRenderer::createLineGeom(GrDrawTarget* target,
                                               GrDrawState* drawState,
+                                              const SkMatrix& viewMatrix,
                                               uint8_t coverage,
                                               size_t vertexStride,
                                               GrDrawTarget::AutoReleaseGeometry* arg,
                                               SkRect* devBounds,
                                               const SkPath& path,
                                               const PtArray& lines,
                                               int lineCnt) {
-    const SkMatrix& viewM = drawState->getViewMatrix();
-
     int vertCnt = kLineSegNumVertices * lineCnt;
 
     SkASSERT(vertexStride == sizeof(LineVertex));
     if (!arg->set(target, vertCnt, vertexStride,  0)) {
         return false;
     }
 
     LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
 
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
-    if (viewM.hasPerspective()) {
-        if (viewM.invert(&ivm)) {
+    if (viewMatrix.hasPerspective()) {
+        if (viewMatrix.invert(&ivm)) {
             toSrc = &ivm;
         }
     }
     devBounds->set(lines.begin(), lines.count());
     for (int i = 0; i < lineCnt; ++i) {
         add_line(&lines[2*i], toSrc, coverage, &verts);
     }
     // All the verts computed by add_line are within sqrt(1^2 + 0.5^2) of the end points.
     static const SkScalar kSqrtOfOneAndAQuarter = 1.118f;
     // Add a little extra to account for vector normalization precision.
     static const SkScalar kOutset = kSqrtOfOneAndAQuarter + SK_Scalar1 / 20;
     devBounds->outset(kOutset, kOutset);
 
     return true;
 }
 
 bool GrAAHairLinePathRenderer::createBezierGeom(GrDrawTarget* target,
                                                 GrDrawState* drawState,
+                                                const SkMatrix& viewMatrix,
                                                 GrDrawTarget::AutoReleaseGeometry* arg,
                                                 SkRect* devBounds,
                                                 const SkPath& path,
                                                 const PtArray& quads,
                                                 int quadCnt,
                                                 const PtArray& conics,
                                                 int conicCnt,
                                                 const IntArray& qSubdivs,
                                                 const FloatArray& cWeights,
                                                 size_t vertexStride) {
-    const SkMatrix& viewM = drawState->getViewMatrix();
-
     int vertCnt = kQuadNumVertices * quadCnt + kQuadNumVertices * conicCnt;
 
     if (!arg->set(target, vertCnt, vertexStride, 0)) {
         return false;
     }
 
     BezierVertex* verts = reinterpret_cast<BezierVertex*>(arg->vertices());
 
     const SkMatrix* toDevice = NULL;
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
-    if (viewM.hasPerspective()) {
-        if (viewM.invert(&ivm)) {
-            toDevice = &viewM;
+    if (viewMatrix.hasPerspective()) {
+        if (viewMatrix.invert(&ivm)) {
+            toDevice = &viewMatrix;
             toSrc = &ivm;
         }
     }
 
     // Seed the dev bounds with some pts known to be inside. Each quad and conic grows the bounding
     // box to include its vertices.
     SkPoint seedPts[2];
     if (quadCnt) {
         seedPts[0] = quads[0];
         seedPts[1] = quads[2];
@@ skipping 14 matching lines @@
 
     // Start Conics
     for (int i = 0; i < conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
     return true;
 }
 
 bool GrAAHairLinePathRenderer::canDrawPath(const GrDrawTarget* target,
                                            const GrDrawState* drawState,
+                                           const SkMatrix& viewMatrix,
                                            const SkPath& path,
                                            const SkStrokeRec& stroke,
                                            bool antiAlias) const {
     if (!antiAlias) {
         return false;
     }
 
-    if (!IsStrokeHairlineOrEquivalent(stroke,
-                                      drawState->getViewMatrix(),
-                                      NULL)) {
+    if (!IsStrokeHairlineOrEquivalent(stroke, viewMatrix, NULL)) {
         return false;
     }
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
 template <class VertexType>
-bool check_bounds(GrDrawState* drawState, const SkRect& devBounds, void* vertices, int vCount)
+bool check_bounds(const SkMatrix& viewMatrix, const SkRect& devBounds, void* vertices, int vCount)
 {
     SkRect tolDevBounds = devBounds;
     // The bounds ought to be tight, but in perspective the below code runs the verts
     // through the view matrix to get back to dev coords, which can introduce imprecision.
-    if (drawState->getViewMatrix().hasPerspective()) {
+    if (viewMatrix.hasPerspective()) {
         tolDevBounds.outset(SK_Scalar1 / 1000, SK_Scalar1 / 1000);
     } else {
         // Non-persp matrices cause this path renderer to draw in device space.
-        SkASSERT(drawState->getViewMatrix().isIdentity());
+        SkASSERT(viewMatrix.isIdentity());
     }
     SkRect actualBounds;
 
     VertexType* verts = reinterpret_cast<VertexType*>(vertices);
     bool first = true;
     for (int i = 0; i < vCount; ++i) {
         SkPoint pos = verts[i].fPos;
         // This is a hack to workaround the fact that we move some degenerate segments offscreen.
         if (SK_ScalarMax == pos.fX) {
             continue;
         }
-        drawState->getViewMatrix().mapPoints(&pos, 1);
+        viewMatrix.mapPoints(&pos, 1);
         if (first) {
             actualBounds.set(pos.fX, pos.fY, pos.fX, pos.fY);
             first = false;
         } else {
             actualBounds.growToInclude(pos.fX, pos.fY);
         }
     }
     if (!first) {
         return tolDevBounds.contains(actualBounds);
     }
 
     return true;
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           GrColor color,
+                                          const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const SkStrokeRec& stroke,
                                           bool antiAlias) {
     SkScalar hairlineCoverage;
     uint8_t newCoverage = 0xff;
-    if (IsStrokeHairlineOrEquivalent(stroke, drawState->getViewMatrix(),
-                                     &hairlineCoverage)) {
+    if (IsStrokeHairlineOrEquivalent(stroke, viewMatrix, &hairlineCoverage)) {
         newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
     }
 
     SkIRect devClipBounds;
     target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
 
     int lineCnt;
     int quadCnt;
     int conicCnt;
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
     IntArray qSubdivs;
     FloatArray cWeights;
-    quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
+    quadCnt = generate_lines_and_quads(path, viewMatrix, devClipBounds,
                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
     lineCnt = lines.count() / 2;
     conicCnt = conics.count() / 3;
 
     // createGeom transforms the geometry to device space when the matrix does not have
     // perspective.
-    GrDrawState::AutoViewMatrixRestore avmr;
+    SkMatrix vm = viewMatrix;
     SkMatrix invert = SkMatrix::I();
-    if (!drawState->getViewMatrix().hasPerspective()) {
-        avmr.setIdentity(drawState);
-        if (!drawState->getViewMatrix().invert(&invert)) {
+    if (!viewMatrix.hasPerspective()) {
+        vm = SkMatrix::I();
+        if (!viewMatrix.invert(&invert)) {
             return false;
         }
     }
 
     // do lines first
     if (lineCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
         GrDrawState::AutoRestoreEffects are(drawState);
         uint32_t gpFlags = GrDefaultGeoProcFactory::kPosition_GPType |
                            GrDefaultGeoProcFactory::kCoverage_GPType;
-        SkAutoTUnref<const GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Create(color,
-                                                                                   gpFlags,
+        SkAutoTUnref<const GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Create(gpFlags,
+                                                                                   color,
+                                                                                   vm,
+                                                                                   invert,
                                                                                    false,
-                                                                                   newCoverage,
-                                                                                   invert));
+                                                                                   newCoverage));
 
         if (!this->createLineGeom(target,
                                   drawState,
+                                  viewMatrix,
                                   newCoverage,
                                   gp->getVertexStride(),
                                   &arg,
                                   &devBounds,
                                   path,
                                   lines,
                                   lineCnt)) {
             return false;
         }
 
         // Check devBounds
-        SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
+        SkASSERT(check_bounds<LineVertex>(viewMatrix.hasPerspective() ? viewMatrix : SkMatrix::I(),
+                                          devBounds,
+                                          arg.vertices(),
                                           kLineSegNumVertices * lineCnt));
 
         {
             target->setIndexSourceToBuffer(fLinesIndexBuffer);
             int lines = 0;
             while (lines < lineCnt) {
                 int n = SkTMin(lineCnt - lines, kLineSegsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     gp,
                                     kTriangles_GrPrimitiveType,
                                     kLineSegNumVertices*lines,     // startV
                                     0,                             // startI
                                     kLineSegNumVertices*n,         // vCount
                                     kIdxsPerLineSeg*n,             // iCount
                                     &devBounds);
                 lines += n;
             }
         }
     }
 
     // then quadratics/conics
     if (quadCnt || conicCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
         if (!this->createBezierGeom(target,
                                     drawState,
+                                    viewMatrix,
                                     &arg,
                                     &devBounds,
                                     path,
                                     quads,
                                     quadCnt,
                                     conics,
                                     conicCnt,
                                     qSubdivs,
                                     cWeights,
                                     sizeof(BezierVertex))) {
             return false;
         }
 
         // Check devBounds
-        SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
-                                            kQuadNumVertices * quadCnt + kQuadNumVertices * conicCnt));
+        SkASSERT(check_bounds<BezierVertex>(viewMatrix.hasPerspective() ? viewMatrix :
+                                                                          SkMatrix::I(),
+                                            devBounds,
+                                            arg.vertices(),
+                                            kQuadNumVertices * quadCnt +
+                                            kQuadNumVertices * conicCnt));
 
         if (quadCnt > 0) {
             SkAutoTUnref<GrGeometryProcessor> hairQuadProcessor(
                     GrQuadEffect::Create(color,
+                                         vm,
                                          kHairlineAA_GrProcessorEdgeType,
                                          *target->caps(),
                                          invert,
                                          newCoverage));
             SkASSERT(hairQuadProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
 
             int quads = 0;
             while (quads < quadCnt) {
                 int n = SkTMin(quadCnt - quads, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     hairQuadProcessor,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*quads,               // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 quads += n;
             }
         }
 
         if (conicCnt > 0) {
             SkAutoTUnref<GrGeometryProcessor> hairConicProcessor(
-                    GrConicEffect::Create(color, kHairlineAA_GrProcessorEdgeType, *target->caps(),
-                                          invert, newCoverage));
+                    GrConicEffect::Create(color, vm, kHairlineAA_GrProcessorEdgeType,
+                                          *target->caps(), invert, newCoverage));
             SkASSERT(hairConicProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
 
             int conics = 0;
             while (conics < conicCnt) {
                 int n = SkTMin(conicCnt - conics, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     hairConicProcessor,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*(quadCnt + conics),  // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }