Move ViewMatrix off of drawstate

src/gpu/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 49 matching lines @@
     SkDELETE(fAtlas);
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrAADistanceFieldPathRenderer::canDrawPath(const GrDrawTarget* target,
                                                 const GrDrawState* drawState,
+                                                const SkMatrix& viewMatrix,
                                                 const SkPath& path,
                                                 const SkStrokeRec& stroke,
                                                 bool antiAlias) const {
     
     // TODO: Support inverse fill
     // TODO: Support strokes
     if (!target->caps()->shaderDerivativeSupport() || !antiAlias || path.isInverseFillType()
         || path.isVolatile() || SkStrokeRec::kFill_Style != stroke.getStyle()) {
         return false;
     }
 
     // currently don't support perspective
-    const SkMatrix& vm = drawState->getViewMatrix();
-    if (vm.hasPerspective()) {
+    if (viewMatrix.hasPerspective()) {
         return false;
     }
     
     // only support paths smaller than 64x64, scaled to less than 256x256
     // the goal is to accelerate rendering of lots of small paths that may be scaling
-    SkScalar maxScale = vm.getMaxScale();
+    SkScalar maxScale = viewMatrix.getMaxScale();
     const SkRect& bounds = path.getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     return maxDim < 64.f && maxDim*maxScale < 256.f;
 }
 
 
 GrPathRenderer::StencilSupport
 GrAADistanceFieldPathRenderer::onGetStencilSupport(const GrDrawTarget*,
                                                    const GrDrawState*,
                                                    const SkPath&,
                                                    const SkStrokeRec&) const {
     return GrPathRenderer::kNoSupport_StencilSupport;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target,
                                                GrDrawState* drawState,
                                                GrColor color,
+                                               const SkMatrix& viewMatrix,
                                                const SkPath& path,
                                                const SkStrokeRec& stroke,
                                                bool antiAlias) {
     // we've already bailed on inverse filled paths, so this is safe
     if (path.isEmpty()) {
         return true;
     }
 
     SkASSERT(fContext);
 
     // get mip level
-    const SkMatrix& vm = drawState->getViewMatrix();
-    SkScalar maxScale = vm.getMaxScale();
+    SkScalar maxScale = viewMatrix.getMaxScale();
     const SkRect& bounds = path.getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     SkScalar size = maxScale*maxDim;
     uint32_t desiredDimension;
     if (size <= kSmallMIP) {
         desiredDimension = kSmallMIP;
     } else if (size <= kMediumMIP) {
         desiredDimension = kMediumMIP;
     } else {
         desiredDimension = kLargeMIP;
     }
 
     // check to see if path is cached
     // TODO: handle stroked vs. filled version of same path
     PathData::Key key = { path.getGenerationID(), desiredDimension };
     PathData* pathData = fPathCache.find(key);
     if (NULL == pathData) {
         SkScalar scale = desiredDimension/maxDim;
         pathData = this->addPathToAtlas(path, stroke, antiAlias, desiredDimension, scale);
         if (NULL == pathData) {
             return false;
         }
     }
 
     // use signed distance field to render
-    return this->internalDrawPath(target, drawState, color, path, pathData);
+    return this->internalDrawPath(target, drawState, color, viewMatrix, path, pathData);
 }
 
 // padding around path bounds to allow for antialiased pixels
 const SkScalar kAntiAliasPad = 1.0f;
 
 GrAADistanceFieldPathRenderer::PathData* GrAADistanceFieldPathRenderer::addPathToAtlas(
                                                                         const SkPath& path,
                                                                         const SkStrokeRec& stroke,
                                                                         bool antiAlias,
                                                                         uint32_t dimension,
@@ skipping 143 matching lines @@
         
     // tell the atlas to free the plot
     GrAtlas::RemovePlot(&fPlotUsage, plot);
     
     return true;
 }
 
 bool GrAADistanceFieldPathRenderer::internalDrawPath(GrDrawTarget* target,
                                                      GrDrawState* drawState,
                                                      GrColor color,
+                                                     const SkMatrix& viewMatrix,
                                                      const SkPath& path,
                                                      const PathData* pathData) {
     GrTexture* texture = fAtlas->getTexture();
     GrDrawState::AutoRestoreEffects are(drawState);
     
     SkASSERT(pathData->fPlot);
     GrDrawTarget::DrawToken drawToken = target->getCurrentDrawToken();
     pathData->fPlot->setDrawToken(drawToken);
     
     // set up any flags
     uint32_t flags = 0;
-    const SkMatrix& vm = drawState->getViewMatrix();
-    flags |= vm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
+    flags |= viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
     GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
-    if (flags != fEffectFlags || fCachedGeometryProcessor->color() != color) {
+    if (flags != fEffectFlags || fCachedGeometryProcessor->color() != color ||
+        !fCachedGeometryProcessor->viewMatrix().cheapEqualTo(viewMatrix)) {
         fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(color,
+                                                                                   viewMatrix,
                                                                                    texture,
                                                                                    params,
                                                                                    flags,
                                                                                    false));
         fEffectFlags = flags;
     }
 
     void* vertices = NULL;
     bool success = target->reserveVertexAndIndexSpace(4,
                                                       fCachedGeometryProcessor->getVertexStride(),
@@ skipping 25 matching lines @@
     
     // vertex texture coords
     intptr_t intPtr = reinterpret_cast<intptr_t>(positions);
     SkPoint* textureCoords = reinterpret_cast<SkPoint*>(intPtr + vertSize - sizeof(SkPoint));
     textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)),
                               SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)),
                               SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)),
                               SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)),
                               vertSize);
     
-    vm.mapRect(&r);
+    viewMatrix.mapRect(&r);
     target->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, fCachedGeometryProcessor.get(),
                                  kTriangles_GrPrimitiveType, 1, 4, 6, &r);
     target->resetVertexSource();
     
     return true;
 }