Move ViewMatrix off of drawstate

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 51 matching lines @@
 
     The vertex attrib order is always pos, color, [local coords].
  */
 static const GrGeometryProcessor* create_rect_gp(bool hasExplicitLocalCoords,
                                                  GrColor color,
                                                  const SkMatrix* localMatrix) {
     uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
                      GrDefaultGeoProcFactory::kColor_GPType;
     flags |= hasExplicitLocalCoords ? GrDefaultGeoProcFactory::kLocalCoord_GPType : 0;
     if (localMatrix) {
-        return GrDefaultGeoProcFactory::Create(color, flags, GrColorIsOpaque(color), 0xff,
-                                               *localMatrix);
+        return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), *localMatrix,
+                                               GrColorIsOpaque(color));
     } else {
-        return GrDefaultGeoProcFactory::Create(color, flags, GrColorIsOpaque(color));
+        return GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), SkMatrix::I(),
+                                               GrColorIsOpaque(color));
     }
 }
 
 static bool path_fill_type_is_winding(const GrStencilSettings& pathStencilSettings) {
     static const GrStencilSettings::Face pathFace = GrStencilSettings::kFront_Face;
     bool isWinding = kInvert_StencilOp != pathStencilSettings.passOp(pathFace);
     if (isWinding) {
         // Double check that it is in fact winding.
         SkASSERT(kIncClamp_StencilOp == pathStencilSettings.passOp(pathFace));
         SkASSERT(kIncClamp_StencilOp == pathStencilSettings.failOp(pathFace));
@@ skipping 22 matching lines @@
 };
 
 static inline uint8_t add_trace_bit(uint8_t cmd) { return cmd | kTraceCmdBit; }
 
 static inline uint8_t strip_trace_bit(uint8_t cmd) { return cmd & kCmdMask; }
 
 static inline bool cmd_has_trace_marker(uint8_t cmd) { return SkToBool(cmd & kTraceCmdBit); }
 
 void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds,
                                      GrColor color,
+                                     const SkMatrix& viewMatrix,
                                      const SkRect& rect,
                                      const SkRect* localRect,
                                      const SkMatrix* localMatrix) {
     GrDrawState::AutoRestoreEffects are(ds);
 
     // Go to device coords to allow batching across matrix changes
-    SkMatrix matrix = ds->getViewMatrix();
     SkMatrix invert = SkMatrix::I();
 
     // if we have a local rect, then we apply the localMatrix directly to the localRect to generate
     // vertex local coords
     bool hasExplicitLocalCoords = SkToBool(localRect);
     if (!hasExplicitLocalCoords) {
-        if (!matrix.isIdentity() && !matrix.invert(&invert)) {
+        if (!viewMatrix.isIdentity() && !viewMatrix.invert(&invert)) {
             SkDebugf("Could not invert\n");
             return;
         }
 
         if (localMatrix) {
             invert.preConcat(*localMatrix);
         }
     }
 
     SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(hasExplicitLocalCoords,
                                                               color,
                                                               &invert));
 
     size_t vstride = gp->getVertexStride();
     SkASSERT(vstride == sizeof(SkPoint) + sizeof(GrColor) + (SkToBool(localRect) ? sizeof(SkPoint) :
                                                                                    0));
     AutoReleaseGeometry geo(this, 4, vstride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
 
+    geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vstride);
+    viewMatrix.mapPointsWithStride(geo.positions(), vstride, 4);
+
     // When the caller has provided an explicit source rect for a stage then we don't want to
     // modify that stage's matrix. Otherwise if the effect is generating its source rect from
-    // the vertex positions then we have to account for the view matrix change.
-    GrDrawState::AutoViewMatrixRestore avmr(ds);
+    // the vertex positions then we have to account for the view matrix
+    SkRect devBounds;
 
-    geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vstride);
-    matrix.mapPointsWithStride(geo.positions(), vstride, 4);
-
-    SkRect devBounds;
     // since we already computed the dev verts, set the bounds hint. This will help us avoid
     // unnecessary clipping in our onDraw().
     get_vertex_bounds(geo.vertices(), vstride, 4, &devBounds);
 
     if (localRect) {
         static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
         SkPoint* coords = GrTCast<SkPoint*>(GrTCast<intptr_t>(geo.vertices()) + kLocalOffset);
         coords->setRectFan(localRect->fLeft, localRect->fTop,
                            localRect->fRight, localRect->fBottom,
                            vstride);
@@ skipping 95 matching lines @@
 
 void GrInOrderDrawBuffer::onStencilPath(const GrDrawState& ds,
                                         const GrPathProcessor* pathProc,
                                         const GrPath* path,
                                         const GrScissorState& scissorState,
                                         const GrStencilSettings& stencilSettings) {
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath,
                                                (path, ds.getRenderTarget()));
     sp->fScissor = scissorState;
     sp->fUseHWAA = ds.isHWAntialias();
-    sp->fViewMatrix = ds.getViewMatrix();
+    sp->fViewMatrix = pathProc->viewMatrix();
     sp->fStencil = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrDrawState& ds,
                                      const GrPathProcessor* pathProc,
                                      const GrPath* path,
                                      const GrScissorState& scissorState,
                                      const GrStencilSettings& stencilSettings,
                                      const GrDeviceCoordTexture* dstCopy) {
@@ skipping 247 matching lines @@
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }