Use uint16s for texture coordinates when rendering 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 "GrBitmapTextContext.h"
@@ skipping 356 matching lines @@
 }
 
 static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
     unsigned r = SkColorGetR(c);
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }
 
 static size_t get_vertex_stride(bool useColorVerts) {
-    return useColorVerts ? (2 * sizeof(SkPoint) + sizeof(GrColor)) :
-                           (2 * sizeof(SkPoint));
+    return useColorVerts ? (sizeof(SkPoint) + sizeof(GrColor) + sizeof(SkIPoint16)) :
+                           (sizeof(SkPoint) + sizeof(SkIPoint16));
 }
 
 static void* alloc_vertices(GrDrawTarget* drawTarget,
                             int numVertices,
                             bool useColorVerts) {
     if (numVertices <= 0) {
         return NULL;
     }
 
     void* vertices = NULL;
@@ skipping 47 matching lines @@
             fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(color,
                                                                                 fViewMatrix,
                                                                                 fCurrTexture,
                                                                                 params,
                                                                                 fGammaTexture,
                                                                                 gammaParams,
                                                                                 lum/255.f,
                                                                                 flags,
                                                                                 opaque));
 #else
-            fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(color,
-                                                                                       fViewMatrix,
-                                                                                       fCurrTexture,
-                                                                                       params,
-                                                                                       flags,
-                                                                                       opaque));
+            fCachedGeometryProcessor.reset(GrDistanceFieldTextureEffect::Create(color,
+                                                                                fViewMatrix,
+                                                                                fCurrTexture,
+                                                                                params,
+                                                                                flags,
+                                                                                opaque));
 #endif
         }
         fEffectTextureUniqueID = textureUniqueID;
         fEffectColor = filteredColor;
         fEffectFlags = flags;
     }
     
 }
 
 inline bool GrDistanceFieldTextContext::uploadGlyph(GrGlyph* glyph, GrFontScaler* scaler) {
@@ skipping 131 matching lines @@
     bool useColorVerts = !fUseLCDText;
 
     if (NULL == fVertices) {
         int maxQuadVertices = kVerticesPerGlyph * fContext->getQuadIndexBuffer()->maxQuads();
         fAllocVertexCount = SkMin32(fTotalVertexCount, maxQuadVertices);
         fVertices = alloc_vertices(fDrawTarget,
                                    fAllocVertexCount,
                                    useColorVerts);
     }
 
-    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);
-
     fVertexBounds.joinNonEmptyArg(glyphRect);
 
+    int u0 = glyph->fAtlasLocation.fX + SK_DistanceFieldInset;
+    int v0 = glyph->fAtlasLocation.fY + SK_DistanceFieldInset;
+    int u1 = u0 + glyph->fBounds.width() - 2*SK_DistanceFieldInset;
+    int v1 = v0 + glyph->fBounds.height() - 2*SK_DistanceFieldInset;
+
     size_t vertSize = get_vertex_stride(useColorVerts);
+    intptr_t vertex = reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex;
 
-    SkPoint* positions = reinterpret_cast<SkPoint*>(
-                               reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex);
-    positions->setRectFan(glyphRect.fLeft, glyphRect.fTop, glyphRect.fRight, glyphRect.fBottom,
-                          vertSize);
+    // V0
+    SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
+    position->set(glyphRect.fLeft, glyphRect.fTop);
+    if (useColorVerts) {
+        SkColor* color = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
+        *color = fPaint.getColor();
+    }
+    SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + vertSize -
+                                                              sizeof(SkIPoint16));
+    textureCoords->set(u0, v0);
+    vertex += 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);
+    // V1
+    position = reinterpret_cast<SkPoint*>(vertex);
+    position->set(glyphRect.fLeft, glyphRect.fBottom);
     if (useColorVerts) {
-        // 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);
-        }
+        SkColor* color = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
+        *color = fPaint.getColor();
     }
+    textureCoords = reinterpret_cast<SkIPoint16*>(vertex + vertSize  - sizeof(SkIPoint16));
+    textureCoords->set(u0, v1);
+    vertex += vertSize;
+
+    // V2
+    position = reinterpret_cast<SkPoint*>(vertex);
+    position->set(glyphRect.fRight, glyphRect.fBottom);
+    if (useColorVerts) {
+        SkColor* color = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
+        *color = fPaint.getColor();
+    }
+    textureCoords = reinterpret_cast<SkIPoint16*>(vertex + vertSize  - sizeof(SkIPoint16));
+    textureCoords->set(u1, v1);
+    vertex += vertSize;
+
+    // V3
+    position = reinterpret_cast<SkPoint*>(vertex);
+    position->set(glyphRect.fRight, glyphRect.fTop);
+    if (useColorVerts) {
+        SkColor* color = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
+        *color = fPaint.getColor();
+    }
+    textureCoords = reinterpret_cast<SkIPoint16*>(vertex + vertSize  - sizeof(SkIPoint16));
+    textureCoords->set(u1, v0);
 
     fCurrVertex += 4;
     
     return true;
 }
 
 void GrDistanceFieldTextContext::flush() {
     if (NULL == fDrawTarget) {
         return;
     }
@@ skipping 47 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }