remove view matrix from context

src/gpu/GrDistanceFieldTextContext.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDistanceFieldTextContext.h"
 #include "GrAtlas.h"
 #include "GrBitmapTextContext.h"
@@ skipping 61 matching lines @@
                                                          (context, props, enable));
     textContext->fFallbackTextContext = GrBitmapTextContext::Create(context, props);
 
     return textContext;
 }
 
 GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
     SkSafeSetNull(fGammaTexture);
 }
 
-bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint) {
+bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint, const SkMatrix& viewMatrix) {
     if (!fEnableDFRendering && !paint.isDistanceFieldTextTEMP()) {
         return false;
     }
 
     // rasterizers and mask filters modify alpha, which doesn't
     // translate well to distance
     if (paint.getRasterizer() || paint.getMaskFilter() ||
         !fContext->getTextTarget()->caps()->shaderDerivativeSupport()) {
         return false;
     }
 
     // TODO: add some stroking support
     if (paint.getStyle() != SkPaint::kFill_Style) {
         return false;
     }
 
     // TODO: choose an appropriate maximum scale for distance fields and
     //       enable perspective
-    if (SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix())) {
+    if (SkDraw::ShouldDrawTextAsPaths(paint, viewMatrix)) {
         return false;
     }
 
     return true;
 }
 
 inline void GrDistanceFieldTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
     GrTextContext::init(paint, skPaint);
 
     fStrike = NULL;
 
-    const SkMatrix& ctm = fContext->getMatrix();
+    const SkMatrix& ctm = fViewMatrix;
 
     // getMaxScale doesn't support perspective, so neither do we at the moment
     SkASSERT(!ctm.hasPerspective());
     SkScalar maxScale = ctm.getMaxScale();
     SkScalar textSize = fSkPaint.getTextSize();
     SkScalar scaledTextSize = textSize;
     // if we have non-unity scale, we need to choose our base text size
     // based on the SkPaint's text size multiplied by the max scale factor
     // TODO: do we need to do this if we're scaling down (i.e. maxScale < 1)?
     if (maxScale > 0 && !SkScalarNearlyEqual(maxScale, SK_Scalar1)) {
@@ skipping 69 matching lines @@
             return;
         }
 
         (*gammaTexture)->writePixels(0, 0, width, height,
                                      (*gammaTexture)->config(), data.get(), 0,
                                      GrContext::kDontFlush_PixelOpsFlag);
     }
 }
 
 void GrDistanceFieldTextContext::onDrawText(const GrPaint& paint, const SkPaint& skPaint,
-                                          const char text[], size_t byteLength,
-                                          SkScalar x, SkScalar y) {
+                                            const SkMatrix& viewMatrix,
+                                            const char text[], size_t byteLength,
+                                            SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
+    fViewMatrix = viewMatrix;
     SkDrawCacheProc          glyphCacheProc = skPaint.getDrawCacheProc();
     SkAutoGlyphCache         autoCache(skPaint, &fDeviceProperties, NULL);
     SkGlyphCache*            cache = autoCache.getCache();
 
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
     SkFixed stopX = 0;
     SkFixed stopY = 0;
     SkFixed origin;
@@ skipping 29 matching lines @@
         alignX = SkScalarHalf(alignX);
         alignY = SkScalarHalf(alignY);
     } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
         alignX = 0;
         alignY = 0;
     }
     x -= alignX;
     y -= alignY;
     SkPoint offset = SkPoint::Make(x, y);
 
-    this->drawPosText(paint, skPaint, text, byteLength, positions.begin(), 2, offset);
+    this->drawPosText(paint, skPaint, viewMatrix, text, byteLength, positions.begin(), 2, offset);
 }
 
 void GrDistanceFieldTextContext::onDrawPosText(const GrPaint& paint, const SkPaint& skPaint,
-                                             const char text[], size_t byteLength,
-                                             const SkScalar pos[], int scalarsPerPosition,
-                                             const SkPoint& offset) {
+                                               const SkMatrix& viewMatrix,
+                                               const char text[], size_t byteLength,
+                                               const SkScalar pos[], int scalarsPerPosition,
+                                               const SkPoint& offset) {
 
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0 /* no raster clip? || fRC->isEmpty()*/) {
         return;
     }
 
+    fViewMatrix = viewMatrix;
     this->init(paint, skPaint);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCacheNoGamma    autoCache(fSkPaint, &fDeviceProperties, NULL);
     SkGlyphCache*              cache = autoCache.getCache();
     GrFontScaler*              fontScaler = GetGrFontScaler(cache);
 
     setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
 
@@ skipping 55 matching lines @@
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
     this->finish();
     
     if (fallbackTxt.count() > 0) {
-        fFallbackTextContext->drawPosText(paint, skPaint, fallbackTxt.begin(), fallbackTxt.count(),
-                                          fallbackPos.begin(), scalarsPerPosition, offset);
+        fFallbackTextContext->drawPosText(paint, skPaint, viewMatrix, fallbackTxt.begin(),
+                                          fallbackTxt.count(), fallbackPos.begin(),
+                                          scalarsPerPosition, offset);
     }
 }
 
 static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
     unsigned r = SkColorGetR(c);
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }
 
@@ skipping 17 matching lines @@
                                                           NULL);
     GrAlwaysAssert(success);
     return vertices;
 }
 
 void GrDistanceFieldTextContext::setupCoverageEffect(const SkColor& filteredColor) {
     GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
     GrTextureParams gammaParams(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
     
     uint32_t textureUniqueID = fCurrTexture->getUniqueID();
-    const SkMatrix& ctm = fContext->getMatrix();
+    const SkMatrix& ctm = fViewMatrix;
     
     // set up any flags
     uint32_t flags = 0;
     flags |= ctm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
     flags |= fUseLCDText ? kUseLCD_DistanceFieldEffectFlag : 0;
     flags |= fUseLCDText && ctm.rectStaysRect() ?
     kRectToRect_DistanceFieldEffectFlag : 0;
     bool useBGR = SkPixelGeometryIsBGR(fDeviceProperties.pixelGeometry());
     flags |= fUseLCDText && useBGR ? kBGR_DistanceFieldEffectFlag : 0;
     
@@ skipping 108 matching lines @@
     dx *= scale;
     dy *= scale;
     sx += dx;
     sy += dy;
     width *= scale;
     height *= scale;
     SkRect glyphRect = SkRect::MakeXYWH(sx, sy, width, height);
 
     // check if we clipped out
     SkRect dstRect;
-    const SkMatrix& ctm = fContext->getMatrix();
+    const SkMatrix& ctm = fViewMatrix;
     (void) ctm.mapRect(&dstRect, glyphRect);
     if (fClipRect.quickReject(SkScalarTruncToInt(dstRect.left()),
                               SkScalarTruncToInt(dstRect.top()),
                               SkScalarTruncToInt(dstRect.right()),
                               SkScalarTruncToInt(dstRect.bottom()))) {
 //            SkCLZ(3);    // so we can set a break-point in the debugger
         return true;
     }
 
     if (NULL == glyph->fPlot) {
         // needs to be a separate conditional to avoid over-optimization
         // on Nexus 7 and Nexus 10
         if (!uploadGlyph(glyph, scaler)) {
             if (NULL == glyph->fPath) {
                 SkPath* path = SkNEW(SkPath);
                 if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                     // flag the glyph as being dead?
                     delete path;
                     return true;
                 }
                 glyph->fPath = path;
             }
 
             // flush any accumulated draws before drawing this glyph as a path.
             this->flush();
 
-            GrContext::AutoMatrix am;
             SkMatrix ctm;
             ctm.setScale(fTextRatio, fTextRatio);
             ctm.postTranslate(sx - dx, sy - dy);
             GrPaint tmpPaint(fPaint);
-            am.setPreConcat(fContext, ctm, &tmpPaint);
+            tmpPaint.localCoordChange(ctm);
+
+            SkMatrix viewM = fViewMatrix;
+            viewM.preConcat(ctm);
             GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
-            fContext->drawPath(tmpPaint, *glyph->fPath, strokeInfo);
+            fContext->drawPath(tmpPaint, viewM, *glyph->fPath, strokeInfo);
 
             // remove this glyph from the vertices we need to allocate
             fTotalVertexCount -= kVerticesPerGlyph;
             return true;
         }
     }
 
     SkASSERT(glyph->fPlot);
     GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
     glyph->fPlot->setDrawToken(drawToken);
@@ skipping 53 matching lines @@
     return true;
 }
 
 void GrDistanceFieldTextContext::flush() {
     if (NULL == fDrawTarget) {
         return;
     }
 
     if (fCurrVertex > 0) {
         GrDrawState drawState;
-        drawState.setFromPaint(fPaint, fContext->getMatrix(), fContext->getRenderTarget());
+        drawState.setFromPaint(fPaint, fViewMatrix, fContext->getRenderTarget());
 
         // setup our sampler state for our text texture/atlas
         SkASSERT(SkIsAlign4(fCurrVertex));
 
         // get our current color
         SkColor filteredColor;
         SkColorFilter* colorFilter = fSkPaint.getColorFilter();
         if (colorFilter) {
             filteredColor = colorFilter->filterColor(fSkPaint.getColor());
         } else {
@@ skipping 32 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }