Hook in rough distance field support for fonts

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 "GrBitmapTextContext.h"
+#include "GrDistanceFieldTextContext.h"
 #include "GrAtlas.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrIndexBuffer.h"
 #include "GrTextStrike.h"
 #include "GrTextStrike_impl.h"
 #include "SkPath.h"
 #include "SkRTConf.h"
 #include "SkStrokeRec.h"
-#include "effects/GrCustomCoordsTextureEffect.h"
+#include "effects/GrDistanceFieldTextureEffect.h"
 
 static const int kGlyphCoordsAttributeIndex = 1;
 
 SK_CONF_DECLARE(bool, c_DumpFontCache, "gpu.dumpFontCache", false,
                 "Dump the contents of the font cache before every purge.");
 
-GrBitmapTextContext::GrBitmapTextContext(GrContext* context, const GrPaint& paint) :
-                                         GrTextContext(context, paint) {
-    fAutoMatrix.setIdentity(fContext, &fPaint);
 
+GrDistanceFieldTextContext::GrDistanceFieldTextContext(GrContext* context, 
+                                                       const GrPaint& paint, 
+                                                       SkScalar textSize) :
+                                         GrTextContext(context, paint),
+                                         fTextSize(textSize) {
     fStrike = NULL;
 
     fCurrTexture = NULL;
     fCurrVertex = 0;
 
     fVertices = NULL;
     fMaxVertices = 0;
 }
 
-GrBitmapTextContext::~GrBitmapTextContext() {
+GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
     this->flushGlyphs();
 }
 
-void GrBitmapTextContext::flushGlyphs() {
+void GrDistanceFieldTextContext::flushGlyphs() {
     if (NULL == fDrawTarget) {
         return;
     }
 
     GrDrawState* drawState = fDrawTarget->drawState();
     GrDrawState::AutoRestoreEffects are(drawState);
-    drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
+    SkMatrix transform;
+    transform.reset();
+    transform = fContext->getMatrix();
+    drawState->setFromPaint(fPaint, transform, fContext->getRenderTarget());
 
     if (fCurrVertex > 0) {
         // setup our sampler state for our text texture/atlas
         SkASSERT(GrIsALIGN4(fCurrVertex));
         SkASSERT(fCurrTexture);
-        GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
+        GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
 
         // This effect could be stored with one of the cache objects (atlas?)
         drawState->addCoverageEffect(
-                                GrCustomCoordsTextureEffect::Create(fCurrTexture, params),
+                                GrDistanceFieldTextureEffect::Create(fCurrTexture, params),
                                 kGlyphCoordsAttributeIndex)->unref();
 
         if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
             if (kOne_GrBlendCoeff != fPaint.getSrcBlendCoeff() ||
                 kISA_GrBlendCoeff != fPaint.getDstBlendCoeff() ||
                 fPaint.numColorStages()) {
                 GrPrintf("LCD Text will not draw correctly.\n");
             }
             // setup blend so that we get mask * paintColor + (1-mask)*dstColor
             drawState->setBlendConstant(fPaint.getColor());
@@ skipping 23 matching lines @@
 namespace {
 
 // position + texture coord
 extern const GrVertexAttrib gTextVertexAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
     {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}
 };
 
 };
 
-void GrBitmapTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
-                                          GrFixed vx, GrFixed vy,
-                                          GrFontScaler* scaler) {
+void GrDistanceFieldTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
+                                                 GrFixed vx, GrFixed vy,
+                                                 GrFontScaler* scaler) {
     if (NULL == fDrawTarget) {
         return;
     }
     if (NULL == fStrike) {
-        fStrike = fContext->getFontCache()->getStrike(scaler);
+        fStrike = fContext->getFontCache()->getStrike(scaler, true);
     }
 
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
+    SkScalar sx = SkFixedToScalar(vx);
+    SkScalar sy = SkFixedToScalar(vy);
+/*
+    // not valid, need to find a different solution for this
     vx += SkIntToFixed(glyph->fBounds.fLeft);
     vy += SkIntToFixed(glyph->fBounds.fTop);
-
+   
     // keep them as ints until we've done the clip-test
     GrFixed width = glyph->fBounds.width();
     GrFixed height = glyph->fBounds.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)) {
 //            SkCLZ(3);    // so we can set a break-point in the debugger
             return;
         }
     }
-
+*/
     if (NULL == glyph->fPlot) {
         if (fStrike->getGlyphAtlas(glyph, scaler)) {
             goto HAS_ATLAS;
         }
 
         // try to clear out an unused plot before we flush
         fContext->getFontCache()->freePlotExceptFor(fStrike);
         if (fStrike->getGlyphAtlas(glyph, scaler)) {
             goto HAS_ATLAS;
         }
@@ skipping 20 matching lines @@
             if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                 // flag the glyph as being dead?
                 delete path;
                 return;
             }
             glyph->fPath = path;
         }
 
         GrContext::AutoMatrix am;
         SkMatrix translate;
-        translate.setTranslate(SkFixedToScalar(vx - SkIntToFixed(glyph->fBounds.fLeft)),
-                               SkFixedToScalar(vy - SkIntToFixed(glyph->fBounds.fTop)));
+        translate.setTranslate(sx, sy);
         GrPaint tmpPaint(fPaint);
         am.setPreConcat(fContext, translate, &tmpPaint);
         SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(tmpPaint, *glyph->fPath, stroke);
         return;
     }
 
 HAS_ATLAS:
     SkASSERT(glyph->fPlot);
     GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
     glyph->fPlot->setDrawToken(drawToken);
 
-    // now promote them to fixed (TODO: Rethink using fixed pt).
-    width = SkIntToFixed(width);
-    height = SkIntToFixed(height);
-
     GrTexture* texture = glyph->fPlot->texture();
     SkASSERT(texture);
 
     if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
         this->flushGlyphs();
         fCurrTexture = texture;
         fCurrTexture->ref();
     }
 
     if (NULL == fVertices) {
@@ skipping 21 matching lines @@
             fMaxVertices = maxQuadVertices;
         }
         bool success = fDrawTarget->reserveVertexAndIndexSpace(fMaxVertices,
                                                                0,
                                                                GrTCast<void**>(&fVertices),
                                                                NULL);
         GrAlwaysAssert(success);
         SkASSERT(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize());
     }
 
+    SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft);
+    SkScalar dy = SkIntToScalar(glyph->fBounds.fTop);
+    SkScalar width = SkIntToScalar(glyph->fBounds.width());
+    SkScalar height = SkIntToScalar(glyph->fBounds.height());
+
+    SkScalar scale = fTextSize/32.f;
+    dx *= scale;
+    dy *= scale;
+    sx += dx;
+    sy += dy;
+    width *= scale;
+    height *= scale;
+
     GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
     GrFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
+    GrFixed tw = SkIntToFixed(glyph->fBounds.width());
+    GrFixed th = SkIntToFixed(glyph->fBounds.height());
 
-    fVertices[2*fCurrVertex].setRectFan(SkFixedToFloat(vx),
-                                        SkFixedToFloat(vy),
-                                        SkFixedToFloat(vx + width),
-                                        SkFixedToFloat(vy + height),
+    fVertices[2*fCurrVertex].setRectFan(sx,
+                                        sy,
+                                        sx + width,
+                                        sy + height,
                                         2 * sizeof(SkPoint));
-    fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
-                                          SkFixedToFloat(texture->normalizeFixedY(ty)),
-                                          SkFixedToFloat(texture->normalizeFixedX(tx + width)),
-                                          SkFixedToFloat(texture->normalizeFixedY(ty + height)),
+    fVertices[2*fCurrVertex+1].setRectFan(SkFixedToScalar(texture->normalizeFixedX(tx)),
+                                          SkFixedToScalar(texture->normalizeFixedY(ty)),
+                                          SkFixedToScalar(texture->normalizeFixedX(tx + tw)),
+                                          SkFixedToScalar(texture->normalizeFixedY(ty + th)),
                                           2 * sizeof(SkPoint));
     fCurrVertex += 4;
 }