Add vertex color support to distance field text.

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 "SkColorFilter.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrFontScaler.h"
 #include "SkGlyphCache.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrStrokeInfo.h"
 #include "GrTextStrike.h"
 #include "GrTextStrike_impl.h"
 #include "SkDistanceFieldGen.h"
 #include "SkDraw.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkRTConf.h"
 #include "SkStrokeRec.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.");
+
+static const int kGlyphCoordsNoColorAttributeIndex = 1;
+static const int kGlyphCoordsWithColorAttributeIndex = 2;
 
 static const int kSmallDFFontSize = 32;
 static const int kSmallDFFontLimit = 32;
 static const int kMediumDFFontSize = 64;
 static const int kMediumDFFontLimit = 64;
 static const int kLargeDFFontSize = 128;
 
-SK_CONF_DECLARE(bool, c_DumpFontCache, "gpu.dumpFontCache", false,
-                "Dump the contents of the font cache before every purge.");
+namespace {
+// position + texture coord
+extern const GrVertexAttrib gTextVertexAttribs[] = {
+    {kVec2f_GrVertexAttribType, 0,                kPosition_GrVertexAttribBinding},
+    {kVec2f_GrVertexAttribType, sizeof(SkPoint) , kEffect_GrVertexAttribBinding}
+};
+
+// position + color + texture coord
+extern const GrVertexAttrib gTextVertexWithColorAttribs[] = {
+    {kVec2f_GrVertexAttribType,  0,                                 kPosition_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint),                   kColor_GrVertexAttribBinding},
+    {kVec2f_GrVertexAttribType,  sizeof(SkPoint) + sizeof(GrColor), kEffect_GrVertexAttribBinding}
+};
+    
+};
 
 GrDistanceFieldTextContext::GrDistanceFieldTextContext(GrContext* context,
                                                        const SkDeviceProperties& properties,
                                                        bool enable)
                                                     : GrTextContext(context, properties) {
 #if SK_FORCE_DISTANCEFIELD_FONTS
     fEnableDFRendering = true;
 #else
     fEnableDFRendering = enable;
 #endif
@@ skipping 57 matching lines @@
 
     if (fCurrVertex > 0) {
         // setup our sampler state for our text texture/atlas
         SkASSERT(SkIsAlign4(fCurrVertex));
         GrTexture* currTexture = fStrike->getTexture();
         SkASSERT(currTexture);
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
         GrTextureParams gammaParams(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
 
         // Effects could be stored with one of the cache objects (atlas?)
+        int coordsIdx = drawState->hasColorVertexAttribute() ? kGlyphCoordsWithColorAttributeIndex :
+                                                               kGlyphCoordsNoColorAttributeIndex;
         SkColor filteredColor;
         SkColorFilter* colorFilter = fSkPaint.getColorFilter();
         if (NULL != colorFilter) {
             filteredColor = colorFilter->filterColor(fSkPaint.getColor());
         } else {
             filteredColor = fSkPaint.getColor();
         }
         if (fUseLCDText) {
             GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);
             bool useBGR = SkDeviceProperties::Geometry::kBGR_Layout ==
                                                             fDeviceProperties.fGeometry.getLayout();
             drawState->addCoverageEffect(GrDistanceFieldLCDTextureEffect::Create(
                                                             currTexture,
                                                             params,
                                                             fGammaTexture,
                                                             gammaParams,
                                                             colorNoPreMul,
                                                             fContext->getMatrix().rectStaysRect() &&
                                                             fContext->getMatrix().isSimilarity(),
                                                             useBGR),
-                                         kGlyphCoordsAttributeIndex)->unref();
+                                         coordsIdx)->unref();
 
             if (kOne_GrBlendCoeff != fPaint.getSrcBlendCoeff() ||
                 kISA_GrBlendCoeff != fPaint.getDstBlendCoeff() ||
                 fPaint.numColorStages()) {
                 GrPrintf("LCD Text will not draw correctly.\n");
             }
+            SkASSERT(!drawState->hasColorVertexAttribute());
             // We don't use the GrPaint's color in this case because it's been premultiplied by
             // alpha. Instead we feed in a non-premultiplied color, and multiply its alpha by
             // the mask texture color. The end result is that we get
             //            mask*paintAlpha*paintColor + (1-mask*paintAlpha)*dstColor
             int a = SkColorGetA(fSkPaint.getColor());
             // paintAlpha
             drawState->setColor(SkColorSetARGB(a, a, a, a));
             // paintColor
             drawState->setBlendConstant(colorNoPreMul);
             drawState->setBlendFunc(kConstC_GrBlendCoeff, kISC_GrBlendCoeff);
         } else {
 #ifdef SK_GAMMA_APPLY_TO_A8
             U8CPU lum = SkColorSpaceLuminance::computeLuminance(fDeviceProperties.fGamma,
                                                                 filteredColor);
             drawState->addCoverageEffect(GrDistanceFieldTextureEffect::Create(
                                                               currTexture, params,
                                                               fGammaTexture, gammaParams,
                                                               lum/255.f,
                                                               fContext->getMatrix().isSimilarity()),
-                                         kGlyphCoordsAttributeIndex)->unref();
+                                         coordsIdx)->unref();
 #else
             drawState->addCoverageEffect(GrDistanceFieldTextureEffect::Create(
                                                               currTexture, params,
                                                               fContext->getMatrix().isSimilarity()),
-                                         kGlyphCoordsAttributeIndex)->unref();
+                                         coordsIdx)->unref();
 #endif
             // set back to normal in case we took LCD path previously.
             drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
-            drawState->setColor(fPaint.getColor());
+            //drawState->setColor(fPaint.getColor());
+            // We're using per-vertex color.
+            SkASSERT(drawState->hasColorVertexAttribute());
+            drawState->setColor(0xFFFFFFFF);
         }
-
         int nGlyphs = fCurrVertex / 4;
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
         fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
                                           nGlyphs,
                                           4, 6);
         fCurrVertex = 0;
     }
     fDrawTarget->resetVertexSource();
     fVertices = NULL;
 }
 
-namespace {
-
-// position + texture coord
-extern const GrVertexAttrib gTextVertexAttribs[] = {
-    {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
-    {kVec2f_GrVertexAttribType, sizeof(SkPoint), kEffect_GrVertexAttribBinding}
-};
-
-};
-
 void GrDistanceFieldTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
                                                  SkFixed vx, SkFixed vy,
                                                  GrFontScaler* scaler) {
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
     SkScalar sx = SkFixedToScalar(vx);
     SkScalar sy = SkFixedToScalar(vy);
@@ skipping 83 matching lines @@
     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);
 
-    static const size_t kVertexSize = 2 * sizeof(SkPoint);
+    size_t vertSize = fUseLCDText ? (2 * sizeof(SkPoint))
+                                  : (2 * sizeof(SkPoint) + sizeof(GrColor));
+    
+    SkASSERT(vertSize == fDrawTarget->getDrawState().getVertexSize());
+    
     SkPoint* positions = reinterpret_cast<SkPoint*>(
-                                reinterpret_cast<intptr_t>(fVertices) + kVertexSize * fCurrVertex);
-    positions->setRectFan(sx,
-                          sy,
-                          sx + width,
-                          sy + height,
-                          kVertexSize);
+        reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex);
+    positions->setRectFan(sx, sy, sx + width, sy + height, 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) + kVertexSize  - sizeof(SkPoint));
+            reinterpret_cast<intptr_t>(positions) + vertSize  - sizeof(SkPoint));
     textureCoords->setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
-                                          SkFixedToFloat(texture->normalizeFixedY(ty)),
-                                          SkFixedToFloat(texture->normalizeFixedX(tx + tw)),
-                                          SkFixedToFloat(texture->normalizeFixedY(ty + th)),
-                                          kVertexSize);
+                              SkFixedToFloat(texture->normalizeFixedY(ty)),
+                              SkFixedToFloat(texture->normalizeFixedX(tx + tw)),
+                              SkFixedToFloat(texture->normalizeFixedY(ty + th)),
+                              vertSize);
+    if (!fUseLCDText) {
+        // color comes after position.
+        GrColor* colors = reinterpret_cast<GrColor*>(positions + 1);
+        for (int i = 0; i < 4; ++i) {
+            *colors = fPaint.getColor();
+            colors = reinterpret_cast<GrColor*>(reinterpret_cast<intptr_t>(colors) + vertSize);
+        }
+    }
+    
     fCurrVertex += 4;
 }
 
 inline void GrDistanceFieldTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
     GrTextContext::init(paint, skPaint);
 
     fStrike = NULL;
 
     fCurrVertex = 0;
 
@@ skipping 13 matching lines @@
     fUseLCDText = fSkPaint.isLCDRenderText();
 
     fSkPaint.setLCDRenderText(false);
     fSkPaint.setAutohinted(false);
     fSkPaint.setHinting(SkPaint::kNormal_Hinting);
     fSkPaint.setSubpixelText(true);
 
 }
 
 inline void GrDistanceFieldTextContext::finish() {
-    flushGlyphs();
+    this->flushGlyphs();
 
     GrTextContext::finish();
 }
 
 static void setup_gamma_texture(GrContext* context, const SkGlyphCache* cache,
                                 const SkDeviceProperties& deviceProperties,
                                 GrTexture** gammaTexture) {
     if (NULL == *gammaTexture) {
         int width, height;
         size_t size;
@@ skipping 56 matching lines @@
     SkGlyphCache*              cache = autoCache.getCache();
     GrFontScaler*              fontScaler = GetGrFontScaler(cache);
     if (NULL == fStrike) {
         fStrike = fContext->getFontCache()->getStrike(fontScaler, true);
     }
 
     setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
 
     // allocate vertices
     SkASSERT(NULL == fVertices);
-    fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
-                                                                SK_ARRAY_COUNT(gTextVertexAttribs));
+    if (!fUseLCDText) {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
+                                                       SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
+    } else {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
+                                                       SK_ARRAY_COUNT(gTextVertexAttribs));
+    }
     int numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
     bool success = fDrawTarget->reserveVertexAndIndexSpace(4*numGlyphs,
                                                            0,
                                                            &fVertices,
                                                            NULL);
     GrAlwaysAssert(success);
 
     // need to measure first
     // TODO - generate positions and pre-load cache as well?
     const char* stop = text + byteLength;
@@ skipping 69 matching lines @@
 
     SkAutoGlyphCacheNoGamma    autoCache(fSkPaint, &fDeviceProperties, NULL);
     SkGlyphCache*              cache = autoCache.getCache();
     GrFontScaler*              fontScaler = GetGrFontScaler(cache);
     if (NULL == fStrike) {
         fStrike = fContext->getFontCache()->getStrike(fontScaler, true);
     }
 
     // allocate vertices
     SkASSERT(NULL == fVertices);
-    fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
-                                                                SK_ARRAY_COUNT(gTextVertexAttribs));
+    if (!fUseLCDText) {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
+                                                       SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
+    } else {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
+                                                       SK_ARRAY_COUNT(gTextVertexAttribs));
+    }
     int numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
     bool success = fDrawTarget->reserveVertexAndIndexSpace(4*numGlyphs,
                                                            0,
                                                            &fVertices,
                                                            NULL);
     GrAlwaysAssert(success);
 
     setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
 
     const char*        stop = text + byteLength;
@@ skipping 32 matching lines @@
                                       SkScalarToFixed(x) - (glyph.fAdvanceX >> alignShift),
                                       SkScalarToFixed(y) - (glyph.fAdvanceY >> alignShift),
                                       fontScaler);
             }
             pos += scalarsPerPosition;
         }
     }
 
     this->finish();
 }