A small patch to enable distance field text in 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 242 matching lines @@
     }
 
     if (blob.fViewMatrix.hasPerspective() != viewMatrix.hasPerspective()) {
         return true;
     }
 
     if (blob.fViewMatrix.hasPerspective() && !blob.fViewMatrix.cheapEqualTo(viewMatrix)) {
         return true;
     }
 
-    if (blob.fViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
-        blob.fViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
-        blob.fViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
-        blob.fViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
-        return true;
-    }
-
     // We only cache one masked version
     if (blob.fKey.fHasBlur &&
         (blob.fBlurRec.fSigma != blurRec.fSigma ||
          blob.fBlurRec.fStyle != blurRec.fStyle ||
          blob.fBlurRec.fQuality != blurRec.fQuality)) {
         return true;
     }
 
     // Similarly, we only cache one version for each style
     if (blob.fKey.fStyle != SkPaint::kFill_Style &&
         (blob.fStrokeInfo.fFrameWidth != paint.getStrokeWidth() ||
          blob.fStrokeInfo.fMiterLimit != paint.getStrokeMiter() ||
          blob.fStrokeInfo.fJoin != paint.getStrokeJoin())) {
         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) +
-                      viewMatrix.getScaleY() * (y - blob.fY) -
-                      blob.fViewMatrix.getTranslateY();
-    if (SkScalarFraction(transX) > SK_ScalarNearlyZero ||
-        SkScalarFraction(transY) > SK_ScalarNearlyZero) {
+    // Identical viewmatrices and we can reuse in all cases
+    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()) {
+        // 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) +
+                          viewMatrix.getScaleY() * (y - blob.fY) -
+                          blob.fViewMatrix.getTranslateY();
+        if (SkScalarFraction(transX) > SK_ScalarNearlyZero ||
+            SkScalarFraction(transY) > SK_ScalarNearlyZero) {
+            return true;
+        }
+
 #ifdef SK_DEBUG
-    static const SkScalar kMinDiscernableTranslation = 0.0625;
-    // As a safeguard when debugging, we store the total error across all translations and print if
-    // the error becomes discernable.  This is pretty unlikely to occur given the tight bounds above
-    // on translation
-    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");
+        static const SkScalar kMinDiscernableTranslation = 0.0625;
+        // As a safeguard when debugging, we store the total error across all translations and print
+        // if the error becomes discernable.  This is pretty unlikely to occur given the tight
+        // bounds above on translation
+        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;
     }
-#endif
-    (*outTransX) = transX;
-    (*outTransY) = transY;
+
     return false;
 }
 
 
 inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix* viewMatrix,
                                                     bool noGamma) {
     skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, viewMatrix, noGamma);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
@@ skipping 44 matching lines @@
 
     if (cacheBlob) {
         if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, blurRec, viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
             fCache->remove(cacheBlob);
             cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
                                                            kGrayTextVASize)));
             this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix, blob, x, y,
-                                     drawFilter, clipRect);
+                                     drawFilter, clipRect, rt, clip, grPaint);
         } else {
             // If we can reuse the blob, then make sure we update the blob's viewmatrix, and x/y
             // offsets
             cacheBlob->fViewMatrix = viewMatrix;
             cacheBlob->fX = x;
             cacheBlob->fY = y;
             fCache->makeMRU(cacheBlob);
         }
     } else {
         if (canCache) {
             cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
                                                            kGrayTextVASize)));
         } else {
             cacheBlob.reset(fCache->createBlob(blob, kGrayTextVASize));
         }
         this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix, blob, x, y,
-                                 drawFilter, clipRect);
+                                 drawFilter, clipRect, rt, clip, grPaint);
     }
 
     cacheBlob->fPaintColor = skPaint.getColor();
     this->flush(fContext->getTextTarget(), blob, cacheBlob, rt, skPaint, grPaint, drawFilter,
                 clip, viewMatrix, clipBounds, x, y, transX, transY);
 }
 
 inline bool GrAtlasTextContext::canDrawAsDistanceFields(const SkPaint& skPaint,
                                                         const SkMatrix& viewMatrix) {
     // TODO: support perspective (need getMaxScale replacement)
@@ skipping 26 matching lines @@
         return false;
     }
 
     return true;
 }
 
 void GrAtlasTextContext::regenerateTextBlob(BitmapTextBlob* cacheBlob,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
-                                            SkDrawFilter* drawFilter, const SkIRect& clipRect) {
+                                            SkDrawFilter* drawFilter, const SkIRect& clipRect,
+                                            GrRenderTarget* rt, const GrClip& clip,
+                                            const GrPaint& paint) {
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         int glyphCount = it.glyphCount();
         size_t textLen = glyphCount * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint for this reason.
         it.applyFontToPaint(&runPaint);
 
         if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
             // A false return from filter() means we should abort the current draw.
             runPaint = skPaint;
             continue;
         }
 
         runPaint.setFlags(fGpuDevice->filterTextFlags(runPaint));
 
-        SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
-                                               false);
-
         // setup vertex / glyphIndex for the new run
         if (run > 0) {
             PerSubRunInfo& newRun = cacheBlob->fRuns[run].fSubRunInfo.back();
             PerSubRunInfo& lastRun = cacheBlob->fRuns[run - 1].fSubRunInfo.back();
 
             newRun.fVertexStartIndex = lastRun.fVertexEndIndex;
             newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
 
             newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
             newRun.fGlyphEndIndex = lastRun.fGlyphEndIndex;
         }
 
-        if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
+        if (this->canDrawAsDistanceFields(runPaint, viewMatrix)) {
+            cacheBlob->setHasDistanceField();
+            SkPaint dfPaint = runPaint;
+            SkScalar textRatio;
+            this->initDistanceFieldPaint(&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;
+            int scalarsPerPosition = 2;
+            switch (it.positioning()) {
+                case SkTextBlob::kDefault_Positioning: {
+                    this->internalDrawDFText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                                             (const char *)it.glyphs(), textLen,
+                                             x + offset.x(), y + offset.y(), clipRect, textRatio,
+                                             &fallbackTxt, &fallbackPos, &dfOffset, runPaint);
+                    break;
+                }
+                case SkTextBlob::kHorizontal_Positioning: {
+                    scalarsPerPosition = 1;
+                    dfOffset = SkPoint::Make(x, y + offset.y());
+                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                                                (const char*)it.glyphs(), textLen, it.pos(),
+                                                scalarsPerPosition, dfOffset, clipRect, textRatio,
+                                                &fallbackTxt, &fallbackPos);
+                    break;
+                }
+                case SkTextBlob::kFull_Positioning: {
+                    dfOffset = SkPoint::Make(x, y);
+                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                                                (const char*)it.glyphs(), textLen, it.pos(),
+                                                scalarsPerPosition, dfOffset, clipRect, textRatio,
+                                                &fallbackTxt, &fallbackPos);
+                    break;
+                }
+            }
+            if (fallbackTxt.count()) {
+                this->fallbackDrawPosText(cacheBlob, run, rt, clip, paint, runPaint, viewMatrix,
+                                          fallbackTxt, fallbackPos, scalarsPerPosition, dfOffset,
+                                          clipRect);
+            }
+
+            SkGlyphCache::AttachCache(cache);
+        } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
-            continue;
-        }
-        cacheBlob->fRuns[run].fDrawAsPaths = false;
-
-        switch (it.positioning()) {
-            case SkTextBlob::kDefault_Positioning:
-                this->internalDrawBMPText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                          (const char *)it.glyphs(), textLen,
-                                          x + offset.x(), y + offset.y(), clipRect);
-                break;
-            case SkTextBlob::kHorizontal_Positioning:
-                this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                             (const char*)it.glyphs(), textLen, it.pos(), 1,
-                                             SkPoint::Make(x, y + offset.y()), clipRect);
-                break;
-            case SkTextBlob::kFull_Positioning:
-                this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                             (const char*)it.glyphs(), textLen, it.pos(), 2,
-                                             SkPoint::Make(x, y), clipRect);
-                break;
+        } else {
+            cacheBlob->setHasBitmap();
+            SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
+                                                   false);
+            switch (it.positioning()) {
+                case SkTextBlob::kDefault_Positioning:
+                    this->internalDrawBMPText(cacheBlob, run, cache, runPaint, color, viewMatrix,
+                                              (const char *)it.glyphs(), textLen,
+                                              x + offset.x(), y + offset.y(), clipRect);
+                    break;
+                case SkTextBlob::kHorizontal_Positioning:
+                    this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
+                                                 (const char*)it.glyphs(), textLen, it.pos(), 1,
+                                                 SkPoint::Make(x, y + offset.y()), clipRect);
+                    break;
+                case SkTextBlob::kFull_Positioning:
+                    this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
+                                                 (const char*)it.glyphs(), textLen, it.pos(), 2,
+                                                 SkPoint::Make(x, y), clipRect);
+                    break;
+            }
+            SkGlyphCache::AttachCache(cache);
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
-
-        SkGlyphCache::AttachCache(cache);
     }
 }
 
 inline void GrAtlasTextContext::initDistanceFieldPaint(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;
@@ skipping 15 matching lines @@
         skPaint->setTextSize(SkIntToScalar(kLargeDFFontSize));
     }
 
     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,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix,
                                                     const SkTDArray<char>& fallbackTxt,
                                                     const SkTDArray<SkScalar>& fallbackPos,
                                                     int scalarsPerPosition,
                                                     const SkPoint& offset,
                                                     const SkIRect& clipRect) {
     SkASSERT(fallbackTxt.count());
-    Run& run = blob->fRuns[0];
+    blob->setHasBitmap();
+    Run& run = blob->fRuns[runIndex];
     PerSubRunInfo& subRun = run.fSubRunInfo.push_back();
     subRun.fOverrideDescriptor.reset(SkNEW(SkAutoDescriptor));
     skPaint.getScalerContextDescriptor(subRun.fOverrideDescriptor,
                                        &fDeviceProperties, &viewMatrix, false);
     SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
                                                     subRun.fOverrideDescriptor->getDesc());
-    this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix,
+    this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, paint.getColor(), viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset, clipRect);
     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);
     blob->fViewMatrix = viewMatrix;
-    blob->fRuns[0].fSubRunInfo.back().fUseLCDText = origPaint.isLCDRenderText();
-    blob->fRuns[0].fSubRunInfo.back().fDrawAsDistanceFields = true;
+    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;
 }
 
 void GrAtlasTextContext::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) {
@@ skipping 10 matching lines @@
                                                             &dfPaint, &textRatio));
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         SkPoint offset;
         this->internalDrawDFText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
                                  byteLength, x, y, clipRect, textRatio, &fallbackTxt, &fallbackPos,
                                  &offset, skPaint);
         SkGlyphCache::AttachCache(cache);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(blob, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
+            this->fallbackDrawPosText(blob, 0, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
                                       fallbackPos, 2, offset, clipRect);
         }
         this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     } else {
         SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
         blob->fViewMatrix = viewMatrix;
 
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                   byteLength, x, y, clipRect);
@@ skipping 20 matching lines @@
         SkAutoTUnref<BitmapTextBlob> blob(this->setupDFBlob(glyphCount, skPaint, viewMatrix, &cache,
                                                             &dfPaint, &textRatio));
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         this->internalDrawDFPosText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset, clipRect,
                                     textRatio, &fallbackTxt, &fallbackPos);
         SkGlyphCache::AttachCache(cache);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(blob, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
+            this->fallbackDrawPosText(blob, 0, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
                                       fallbackPos, scalarsPerPosition, offset, clipRect);
         }
         this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     } else {
         SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
         blob->fViewMatrix = viewMatrix;
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                      byteLength, pos, scalarsPerPosition, offset, clipRect);
         SkGlyphCache::AttachCache(cache);
@@ skipping 771 matching lines @@
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen;
             bool regenerateColors;
             if (fUseDistanceFields) {
-                regenerateColors = fUseLCDText && run.fColor != args.fColor;
+                regenerateColors = !fUseLCDText && run.fColor != args.fColor;
             } else {
                 regenerateColors = kA8_GrMaskFormat == fMaskFormat && run.fColor != args.fColor;
             }
             bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
             // We regenerate both texture coords and colors in the blob itself, and update the
             // atlas generation.  If we don't end up purging any unused plots, we can avoid
             // regenerating the coords.  We could take a finer grained approach to updating texture
             // coords but its not clear if the extra bookkeeping would offset any gains.
@@ skipping 543 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);
 }