Some distance field text optimizations.

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 105 matching lines @@
     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())) {
         return false;
     }
 
-    // distance fields cannot represent color fonts
-    SkScalerContext::Rec    rec;
-    SkScalerContext::MakeRec(paint, &fDeviceProperties, NULL, &rec);
-    return rec.getFormat() != SkMask::kARGB32_Format;
+    return true;
 }
 
 inline void GrDistanceFieldTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
     GrTextContext::init(paint, skPaint);
 
     fStrike = NULL;
 
     const SkMatrix& ctm = fContext->getMatrix();
 
     // getMaxScale doesn't support perspective, so neither do we at the moment
@@ skipping 287 matching lines @@
 #ifdef SK_GAMMA_APPLY_TO_A8
             U8CPU lum = SkColorSpaceLuminance::computeLuminance(fDeviceProperties.gamma(),
                                                                 filteredColor);
             fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(fCurrTexture,
                                                                                 params,
                                                                                 fGammaTexture,
                                                                                 gammaParams,
                                                                                 lum/255.f,
                                                                                 flags));
 #else
-            fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(fCurrTexture,
+            fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(fCurrTexture,
                                                                                 params, flags));
 #endif
         }
         fEffectTextureUniqueID = textureUniqueID;
         fEffectColor = filteredColor;
         fEffectFlags = flags;
     }
     
 }
 
@@ skipping 13 matching lines @@
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return true;
     }
 
     // fallback to color glyph support
     if (kA8_GrMaskFormat != glyph->fMaskFormat) {
         return false;
     }
 
-/*
-    // not valid, need to find a different solution for this
-    vx += SkIntToFixed(glyph->fBounds.fLeft);
-    vy += SkIntToFixed(glyph->fBounds.fTop);
+    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);
 
-    // keep them as ints until we've done the clip-test
-    GrFixed width = glyph->fBounds.width();
-    GrFixed height = glyph->fBounds.height();
+    SkScalar scale = fTextRatio;
+    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
-    if (true || NULL == glyph->fPlot) {
-        int x = vx >> 16;
-        int y = vy >> 16;
-        if (fClipRect.quickReject(x, y, x + width, y + height)) {
+    SkRect dstRect;
+    const SkMatrix& ctm = fContext->getMatrix();

[robertphillips, 2014/10/31 19:09:13]

Is there anything we can do with the device space rect?

+    (void) ctm.mapRect(&dstRect, glyphRect);
+    if (fClipRect.quickReject(dstRect.left(), dstRect.top(),
+                              dstRect.right(), dstRect.bottom())) {
 //            SkCLZ(3);    // so we can set a break-point in the debugger
-            return;
-        }
+        return true;
     }
-*/
+
     if (NULL == glyph->fPlot) {
         if (!fStrike->glyphTooLargeForAtlas(glyph)) {
             if (fStrike->addGlyphToAtlas(glyph, scaler)) {
                 goto HAS_ATLAS;
             }
 
             // try to clear out an unused plot before we flush
             if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) &&
                 fStrike->addGlyphToAtlas(glyph, scaler)) {
                 goto HAS_ATLAS;
@@ skipping 58 matching lines @@
     }
 
     bool useColorVerts = !fUseLCDText;
 
     if (NULL == fVertices) {
         int maxQuadVertices = kVerticesPerGlyph * fContext->getQuadIndexBuffer()->maxQuads();
         fAllocVertexCount = SkMin32(fTotalVertexCount, maxQuadVertices);
         fVertices = alloc_vertices(fDrawTarget, fAllocVertexCount, useColorVerts);
     }
 
-    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 += dx;
-    sy += dy;
-    width *= scale;
-    height *= scale;
-
     SkFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX + SK_DistanceFieldInset);
     SkFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY + SK_DistanceFieldInset);
     SkFixed tw = SkIntToFixed(glyph->fBounds.width() - 2*SK_DistanceFieldInset);
     SkFixed th = SkIntToFixed(glyph->fBounds.height() - 2*SK_DistanceFieldInset);
 
-    SkRect r;
-    r.fLeft = sx;
-    r.fTop = sy;
-    r.fRight = sx + width;
-    r.fBottom = sy + height;
-
-    fVertexBounds.joinNonEmptyArg(r);
+    fVertexBounds.joinNonEmptyArg(glyphRect);
 
     size_t vertSize = fUseLCDText ? (2 * sizeof(SkPoint))
                                   : (2 * sizeof(SkPoint) + sizeof(GrColor));
     
     SkASSERT(vertSize == fDrawTarget->getDrawState().getVertexStride());
 
     SkPoint* positions = reinterpret_cast<SkPoint*>(
                                reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex);
-    positions->setRectFan(r.fLeft, r.fTop, r.fRight, r.fBottom, vertSize);
+    positions->setRectFan(glyphRect.fLeft, glyphRect.fTop, glyphRect.fRight, glyphRect.fBottom,
+                          vertSize);
 
     // The texture coords are last in both the with and without color vertex layouts.
     SkPoint* textureCoords = reinterpret_cast<SkPoint*>(
                                reinterpret_cast<intptr_t>(positions) + 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);
     if (useColorVerts) {
@@ skipping 79 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }