Use Color Processor for color bitmap text draws on gpu.

src/gpu/GrBitmapTextContext.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 "GrAtlas.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrIndexBuffer.h"
 #include "GrStrokeInfo.h"
 #include "GrTexturePriv.h"
 #include "GrTextStrike.h"
 #include "GrTextStrike_impl.h"
 #include "effects/GrCustomCoordsTextureEffect.h"
+#include "effects/GrSimpleTextureEffect.h"
 
 #include "SkAutoKern.h"
 #include "SkColorPriv.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkGr.h"
 #include "SkPath.h"
 #include "SkRTConf.h"
 #include "SkStrokeRec.h"
 #include "SkTextMapStateProc.h"
 
 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), kGeometryProcessor_GrVertexAttribBinding}
 };
 
-static const size_t kTextVASize = 2 * sizeof(SkPoint); 
+static const size_t kTextVASize = 2 * sizeof(SkPoint);
+
+// position + local coord
+extern const GrVertexAttrib gTextVertexWithLCAttribs[] = {

[bsalomon, 2014/10/30 15:31:11]

gBmpTextVertexAttribs?

[jvanverth1, 2014/10/30 18:19:43]

I think it's more consistent the way it is.

[egdaniel, 2014/10/30 19:22:20]

I'm in agreement with jim. The way the old names were set up was to describe
what is in the VA array. For example gTextVertexWithColorAttribs contains Color
attribs (but is actually used for grey scale).

gBmpTextVertexAttribs seems even more vague since technically all of these are
bitmap text.

If we want to describe use, we can change them all to:

gLCDTextVertexAttribs
gColorTextVertexAttribs
gBWTextVertexAttribs

+    {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
+    {kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttribBinding}
+};
+
+static const size_t kTextVALCSize = 2 * sizeof(SkPoint);
 
 // 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), kGeometryProcessor_GrVertexAttribBinding}
 };
 
 static const size_t kTextVAColorSize = 2 * sizeof(SkPoint) + sizeof(GrColor);
 
@@ skipping 286 matching lines @@
                                       fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
 
     this->finish();
 }
 
-static void* alloc_vertices(GrDrawTarget* drawTarget, int numVertices, bool useColorVerts) {
+static void* alloc_vertices(GrDrawTarget* drawTarget, int numVertices, GrMaskFormat maskFormat) {
     if (numVertices <= 0) {
         return NULL;
     }
 
     // set up attributes
-    if (useColorVerts) {
+    if (kA8_GrMaskFormat == maskFormat) {
         drawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
                                     SK_ARRAY_COUNT(gTextVertexWithColorAttribs), kTextVAColorSize);
+    } else if (kARGB_GrMaskFormat == maskFormat) {
+        drawTarget->drawState()->setVertexAttribs<gTextVertexWithLCAttribs>(
+                                    SK_ARRAY_COUNT(gTextVertexWithLCAttribs), kTextVALCSize);
     } else {
         drawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
                                     SK_ARRAY_COUNT(gTextVertexAttribs), kTextVASize);
     }
     void* vertices = NULL;
     bool success = drawTarget->reserveVertexAndIndexSpace(numVertices,
                                                           0,
                                                           &vertices,
                                                           NULL);
     GrAlwaysAssert(success);
@@ skipping 102 matching lines @@
     GrTexture* texture = glyph->fPlot->texture();
     SkASSERT(texture);
 
     if (fCurrTexture != texture || fCurrVertex + kVerticesPerGlyph > fAllocVertexCount) {
         this->flush();
         fCurrTexture = texture;
         fCurrTexture->ref();
         fCurrMaskFormat = glyph->fMaskFormat;
     }
 
-    bool useColorVerts = kA8_GrMaskFormat == fCurrMaskFormat;
-
     if (NULL == fVertices) {
         int maxQuadVertices = kVerticesPerGlyph * fContext->getQuadIndexBuffer()->maxQuads();
         fAllocVertexCount = SkMin32(fTotalVertexCount, maxQuadVertices);
-        fVertices = alloc_vertices(fDrawTarget, fAllocVertexCount, useColorVerts);
+        fVertices = alloc_vertices(fDrawTarget, fAllocVertexCount, fCurrMaskFormat);
     }
 
     SkFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
     SkFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
 
     SkRect r;
     r.fLeft = SkFixedToFloat(vx);
     r.fTop = SkFixedToFloat(vy);
     r.fRight = SkFixedToFloat(vx + width);
     r.fBottom = SkFixedToFloat(vy + height);
 
     fVertexBounds.joinNonEmptyArg(r);
 
-    size_t vertSize = useColorVerts ? (2 * sizeof(SkPoint) + sizeof(GrColor)) :
-                                      (2 * sizeof(SkPoint));
+    size_t vertSize;
+    switch (fCurrMaskFormat) {
+        case kA8_GrMaskFormat:
+            vertSize = kTextVAColorSize;
+            break;
+        case kARGB_GrMaskFormat:
+            vertSize = kTextVALCSize;
+        default:
+            vertSize = kTextVASize;
+    }
 
     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);
 
     // 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 + width)),
                               SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + height)),
                               vertSize);
-    if (useColorVerts) {
+    if (kA8_GrMaskFormat == fCurrMaskFormat) {
         if (0xFF == GrColorUnpackA(fPaint.getColor())) {
             fDrawTarget->drawState()->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
         }
         // 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);
         }
     }
@@ skipping 15 matching lines @@
     GrDrawState* drawState = fDrawTarget->drawState();
     GrDrawState::AutoRestoreEffects are(drawState);
     drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
 
     if (fCurrVertex > 0) {
         // setup our sampler state for our text texture/atlas
         SkASSERT(SkIsAlign4(fCurrVertex));
         SkASSERT(fCurrTexture);
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
 
-        uint32_t textureUniqueID = fCurrTexture->getUniqueID();
+        // This effect could be stored with one of the cache objects (atlas?)
+        if (kARGB_GrMaskFormat != fCurrMaskFormat) {

[bsalomon, 2014/10/30 15:31:11]

Switch the sense of this?  Seems easier to read

if (something) { do-for-something } else { do-for-other-cases }

+            uint32_t textureUniqueID = fCurrTexture->getUniqueID();
+            if (textureUniqueID != fEffectTextureUniqueID) {
+                fCachedGeometryProcessor.reset(GrCustomCoordsTextureEffect::Create(fCurrTexture,
+                                                                                   params));
+                fEffectTextureUniqueID = textureUniqueID;
+            }
 
-        if (textureUniqueID != fEffectTextureUniqueID) {
-            fCachedGeometryProcessor.reset(GrCustomCoordsTextureEffect::Create(fCurrTexture,
-                                                                               params));
-            fEffectTextureUniqueID = textureUniqueID;
+            drawState->setGeometryProcessor(fCachedGeometryProcessor.get());
+        } else {
+            SkMatrix matrix;
+            matrix.reset();
+            GrFragmentProcessor* fragProcessor = GrSimpleTextureEffect::Create(fCurrTexture,
+                                                                               matrix,

[jvanverth1, 2014/10/30 18:19:42]

I think you can use SkMatrix::I() instead of having to create a new one and call
reset().

+                                                                               params);
+            drawState->addColorProcessor(fragProcessor)->unref();
         }
 
-        // This effect could be stored with one of the cache objects (atlas?)
-        drawState->setGeometryProcessor(fCachedGeometryProcessor.get());
         SkASSERT(fStrike);
         switch (fCurrMaskFormat) {
                 // Color bitmap text
             case kARGB_GrMaskFormat:
                 SkASSERT(!drawState->hasColorVertexAttribute());
                 drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
                 drawState->setAlpha(fSkPaint.getAlpha());
                 break;
                 // LCD text
             case kA888_GrMaskFormat:
@@ skipping 43 matching lines @@
     }
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }