Add support for rotating / scaling / translating gpu cached distance field textblobs

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 269 matching lines @@
     if (blob.fViewMatrix.cheapEqualTo(viewMatrix) && x == blob.fX && y == blob.fY) {
         return false;
     }
 
     // Mixed blobs must be regenerated.  We could probably figure out a way to do integer scrolls
     // for mixed blobs if this becomes an issue.
     if (blob.hasBitmap() && blob.hasDistanceField()) {
         return true;
     }
 
-    // TODO distance fields can handle many of these conditions
-    if (blob.fViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
-        blob.fViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
-        blob.fViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
-        blob.fViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
-        return true;
-    }
-
     if (blob.hasBitmap()) {
+        if (blob.fViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
+            blob.fViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
+            blob.fViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
+            blob.fViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
+            return true;
+        }
+
         // We can update the positions in the cachedtextblobs without regenerating the whole blob,
         // but only for integer translations.
         // This cool bit of math will determine the necessary translation to apply to the already
         // generated vertex coordinates to move them to the correct position
         SkScalar transX = viewMatrix.getTranslateX() +
                           viewMatrix.getScaleX() * (x - blob.fX) +
                           viewMatrix.getSkewX() * (y - blob.fY) -
                           blob.fViewMatrix.getTranslateX();
         SkScalar transY = viewMatrix.getTranslateY() +
                           viewMatrix.getSkewY() * (x - blob.fX) +
@@ skipping 12 matching lines @@
         blob.fTotalXError += SkScalarAbs(SkScalarFraction(transX));
         blob.fTotalYError += SkScalarAbs(SkScalarFraction(transY));
         if (blob.fTotalXError > kMinDiscernableTranslation ||
             blob.fTotalYError > kMinDiscernableTranslation) {
             SkDebugf("Exceeding error threshold for bitmap text translation");
         }
 #endif
         (*outTransX) = transX;
         (*outTransY) = transY;
     } else {
-        // blob.hasDistanceField()
-        // TODO figure out the regen formula
-        return true;
+        SkASSERT(blob.hasDistanceField());
+        // A scale outside of [blob.fMaxMinScale, blob.fMinMaxScale] would result in a different
+        // distance field being generated, so we have to regenerate in those cases
+        SkScalar newMaxScale = viewMatrix.getMaxScale();
+        SkScalar oldMaxScale = blob.fViewMatrix.getMaxScale();
+        SkScalar scaleAdjust = newMaxScale / oldMaxScale;
+        if (scaleAdjust < blob.fMaxMinScale || scaleAdjust > blob.fMinMaxScale) {
+            return true;
+        }
+
+        (*outTransX) = x - blob.fX;
+        (*outTransY) = y - blob.fY;
     }
 
     return false;
 }
 
 
 inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix* viewMatrix,
                                                     bool noGamma) {
@@ skipping 152 matching lines @@
             newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
 
             newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
             newRun.fGlyphEndIndex = lastRun.fGlyphEndIndex;
         }
 
         if (this->canDrawAsDistanceFields(runPaint, viewMatrix)) {
             cacheBlob->setHasDistanceField();
             SkPaint dfPaint = runPaint;
             SkScalar textRatio;
-            this->initDistanceFieldPaint(&dfPaint, &textRatio, viewMatrix);
+            this->initDistanceFieldPaint(cacheBlob, &dfPaint, &textRatio, viewMatrix);
             Run& runIdx = cacheBlob->fRuns[run];
             PerSubRunInfo& subRun = runIdx.fSubRunInfo.back();
             subRun.fUseLCDText = runPaint.isLCDRenderText();
             subRun.fDrawAsDistanceFields = true;
 
             SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], dfPaint, NULL, true);
 
             SkTDArray<char> fallbackTxt;
             SkTDArray<SkScalar> fallbackPos;
             SkPoint dfOffset;
@@ skipping 57 matching lines @@
             SkGlyphCache::AttachCache(cache);
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
     }
 }
 
-inline void GrAtlasTextContext::initDistanceFieldPaint(SkPaint* skPaint, SkScalar* textRatio,
+inline void GrAtlasTextContext::initDistanceFieldPaint(BitmapTextBlob* blob,
+                                                       SkPaint* skPaint,
+                                                       SkScalar* textRatio,
                                                        const SkMatrix& viewMatrix) {
     // getMaxScale doesn't support perspective, so neither do we at the moment
     SkASSERT(!viewMatrix.hasPerspective());
     SkScalar maxScale = viewMatrix.getMaxScale();
     SkScalar textSize = skPaint->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)) {
         scaledTextSize *= maxScale;
     }
 
+    // We have three sizes of distance field text, and within each size 'bucket' there is a floor
+    // and ceiling.  A scale outside of this range would require regenerating the distance fields
+    SkScalar dfMaskScaleFloor;
+    SkScalar dfMaskScaleCeil;
     if (scaledTextSize <= kSmallDFFontLimit) {
+        dfMaskScaleFloor = kMinDFFontSize;
+        dfMaskScaleCeil = kMediumDFFontLimit;
         *textRatio = textSize / kSmallDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kSmallDFFontSize));
     } else if (scaledTextSize <= kMediumDFFontLimit) {
+        dfMaskScaleFloor = kMediumDFFontLimit;
+        dfMaskScaleCeil = kLargeDFFontSize;
         *textRatio = textSize / kMediumDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kMediumDFFontSize));
     } else {
+        dfMaskScaleFloor = kLargeDFFontSize;
+        dfMaskScaleCeil = 2 * kLargeDFFontSize;
         *textRatio = textSize / kLargeDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kLargeDFFontSize));
     }
 
+    // Because there can be multiple runs in the blob, we want the overall maxMinScale, and
+    // minMaxScale to make regeneration decisions.  Specifically, we want the maximum minimum scale
+    // we can tolerate before we'd drop to a lower mip size, and the minimum maximum scale we can
+    // tolerate before we'd have to move to a large mip size.  When we actually test these values
+    // we look at the delta in scale between the new viewmatrix and the old viewmatrix, and test
+    // against these values to decide if we can reuse or not(ie, will a given scale change our mip
+    // level)
+    blob->fMaxMinScale = SkMaxScalar(dfMaskScaleFloor / scaledTextSize, blob->fMaxMinScale);
+    blob->fMinMaxScale = SkMinScalar(dfMaskScaleCeil / scaledTextSize, blob->fMinMaxScale);
+
     skPaint->setLCDRenderText(false);
     skPaint->setAutohinted(false);
     skPaint->setHinting(SkPaint::kNormal_Hinting);
     skPaint->setSubpixelText(true);
 }
 
 inline void GrAtlasTextContext::fallbackDrawPosText(BitmapTextBlob* blob,
                                                     int runIndex,
                                                     GrRenderTarget* rt, const GrClip& clip,
                                                     const GrPaint& paint,
@@ skipping 19 matching lines @@
     SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextContext::BitmapTextBlob*
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkGlyphCache** cache,
                                 SkPaint* dfPaint, SkScalar* textRatio) {
     BitmapTextBlob* blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
 
     *dfPaint = origPaint;
-    this->initDistanceFieldPaint(dfPaint, textRatio, viewMatrix);
+    this->initDistanceFieldPaint(blob, dfPaint, textRatio, viewMatrix);
     blob->fViewMatrix = viewMatrix;
     Run& run = blob->fRuns[0];
     PerSubRunInfo& subRun = run.fSubRunInfo.back();
     subRun.fUseLCDText = origPaint.isLCDRenderText();
     subRun.fDrawAsDistanceFields = true;
 
     *cache = this->setupCache(&blob->fRuns[0], *dfPaint, NULL, true);
     return blob;
 }
 
@@ skipping 1458 matching lines @@
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }