Calculate inverse scale for distance fields in vertex shader

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 "GrAtlasTextContext.h"
@@ skipping 253 matching lines @@
         fPaint.setColor(GrColorPackRGBA(0x7F, 0x00, 0x00, 0xFF));
 #endif
     }
 
     fUseLCDText = fSkPaint.isLCDRenderText();
 
     fSkPaint.setLCDRenderText(false);
     fSkPaint.setAutohinted(false);
     fSkPaint.setHinting(SkPaint::kNormal_Hinting);
     fSkPaint.setSubpixelText(true);
+    
+    // include any scaling to match text size in the view matrix
+    fViewMatrix.preScale(fTextRatio, fTextRatio);
 }
 
 void GrDistanceFieldTextContext::onDrawText(GrRenderTarget* rt, const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
                                             SkScalar x, SkScalar y,
                                             const SkIRect& regionClipBounds) {
     SkASSERT(byteLength == 0 || text != NULL);
 
@@ skipping 192 matching lines @@
     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;
-    
+
+    // set the local matrix to correct any text size scaling for gradients et al.
+    SkMatrix localMatrix;
+    localMatrix.setScale(fTextRatio, fTextRatio);
+
     // see if we need to create a new effect
     if (textureUniqueID != fEffectTextureUniqueID ||
         filteredColor != fEffectColor ||
         flags != fEffectFlags ||
-        !fCachedGeometryProcessor->viewMatrix().cheapEqualTo(fViewMatrix)) {
+        !fCachedGeometryProcessor->viewMatrix().cheapEqualTo(fViewMatrix) ||
+        !fCachedGeometryProcessor->localMatrix().cheapEqualTo(localMatrix)) {
         GrColor color = fPaint.getColor();
+
         if (fUseLCDText) {
             GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);
 
             float redCorrection = 
                 fDistanceAdjustTable[GrColorUnpackR(colorNoPreMul) >> kDistanceAdjustLumShift];
             float greenCorrection = 
                 fDistanceAdjustTable[GrColorUnpackG(colorNoPreMul) >> kDistanceAdjustLumShift];
             float blueCorrection = 
                 fDistanceAdjustTable[GrColorUnpackB(colorNoPreMul) >> kDistanceAdjustLumShift];
             GrDistanceFieldLCDTextureEffect::DistanceAdjust widthAdjust =
                 GrDistanceFieldLCDTextureEffect::DistanceAdjust::Make(redCorrection,
                                                                    greenCorrection,
                                                                    blueCorrection);
             fCachedGeometryProcessor.reset(GrDistanceFieldLCDTextureEffect::Create(color,
                                                                                    fViewMatrix,
+                                                                                   localMatrix,
                                                                                    fCurrTexture,
                                                                                    params,
                                                                                    widthAdjust,
                                                                                    flags));
         } else {
             flags |= kColorAttr_DistanceFieldEffectFlag;
             bool opaque = GrColorIsOpaque(color);
 #ifdef SK_GAMMA_APPLY_TO_A8
             U8CPU lum = SkColorSpaceLuminance::computeLuminance(fDeviceProperties.gamma(),
                                                                 filteredColor);
             float correction = fDistanceAdjustTable[lum >> kDistanceAdjustLumShift];
             fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(color,
                                                                                 fViewMatrix,
+                                                                                localMatrix,
                                                                                 fCurrTexture,
                                                                                 params,
                                                                                 correction,
                                                                                 flags,
                                                                                 opaque));
 #else
             fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(color,
                                                                                 fViewMatrix,
+                                                                                localMatrix,
                                                                                 fCurrTexture,
                                                                                 params,
                                                                                 flags,
                                                                                 opaque));
 #endif
         }
         fEffectTextureUniqueID = textureUniqueID;
         fEffectColor = filteredColor;
         fEffectFlags = flags;
     }
@@ skipping 58 matching lines @@
     if (kA8_GrMaskFormat != glyph->fMaskFormat) {
         return false;
     }
 
     SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft + SK_DistanceFieldInset);
     SkScalar dy = SkIntToScalar(glyph->fBounds.fTop + SK_DistanceFieldInset);
     SkScalar width = SkIntToScalar(glyph->fBounds.width() - 2*SK_DistanceFieldInset);
     SkScalar height = SkIntToScalar(glyph->fBounds.height() - 2*SK_DistanceFieldInset);
 
     SkScalar scale = fTextRatio;
-    dx *= scale;
-    dy *= scale;
+    sx /= scale;
+    sy /= 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 = fViewMatrix;
     (void) ctm.mapRect(&dstRect, glyphRect);
     if (fClipRect.quickReject(SkScalarTruncToInt(dstRect.left()),
                               SkScalarTruncToInt(dstRect.top()),
                               SkScalarTruncToInt(dstRect.right()),
                               SkScalarTruncToInt(dstRect.bottom()))) {
@@ skipping 13 matching lines @@
                     delete path;
                     return true;
                 }
                 glyph->fPath = path;
             }
 
             // flush any accumulated draws before drawing this glyph as a path.
             this->flush();
 
             SkMatrix ctm;
-            ctm.setScale(fTextRatio, fTextRatio);
             ctm.postTranslate(sx - dx, sy - dy);
 
             SkPath tmpPath(*glyph->fPath);
             tmpPath.transform(ctm);
 
             GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
             fContext->drawPath(fRenderTarget, fClip, fPaint, fViewMatrix, tmpPath, strokeInfo);
 
             // remove this glyph from the vertices we need to allocate
             fTotalVertexCount -= kVerticesPerGlyph;
@@ skipping 137 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }