Use unorm shorts for texture coordinates when rendering text.

src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBlob.h"
 
 #include "GrBatchFlushState.h"
 #include "GrTextUtils.h"
 
 #include "SkDistanceFieldGen.h"
 #include "SkGlyphCache.h"
 
 #include "batches/GrAtlasTextBatch.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // A large template to handle regenerating the vertices of a textblob with as few branches as
 // possible
 template <bool regenPos, bool regenCol, bool regenTexCoords>
 inline void regen_vertices(intptr_t vertex, const GrGlyph* glyph, size_t vertexStride,
                            bool useDistanceFields, SkScalar transX, SkScalar transY,
+                           int32_t log2Width, int32_t log2Height,
                            GrColor color) {
     int u0, v0, u1, v1;
     if (regenTexCoords) {
         SkASSERT(glyph);
         int width = glyph->fBounds.width();
         int height = glyph->fBounds.height();
 
         if (useDistanceFields) {
             u0 = glyph->fAtlasLocation.fX + SK_DistanceFieldInset;
             v0 = glyph->fAtlasLocation.fY + SK_DistanceFieldInset;
             u1 = u0 + width - 2 * SK_DistanceFieldInset;
             v1 = v0 + height - 2 * SK_DistanceFieldInset;
         } else {
             u0 = glyph->fAtlasLocation.fX;
             v0 = glyph->fAtlasLocation.fY;
             u1 = u0 + width;
             v1 = v0 + height;
         }
+
+        // normalize
+        u0 *= 65535;
+        u0 >>= log2Width;
+        u1 *= 65535;
+        u1 >>= log2Width;
+        v0 *= 65535;
+        v0 >>= log2Height;
+        v1 *= 65535;
+        v1 >>= log2Height;
+        SkASSERT(u0 >= 0 && u0 <= 65535);
+        SkASSERT(u1 >= 0 && u1 <= 65535);
+        SkASSERT(v0 >= 0 && v0 <= 65535);
+        SkASSERT(v1 >= 0 && v1 <= 65535);
     }
 
     // This is a bit wonky, but sometimes we have LCD text, in which case we won't have color
     // vertices, hence vertexStride - sizeof(SkIPoint16)
     intptr_t colorOffset = sizeof(SkPoint);
     intptr_t texCoordOffset = vertexStride - sizeof(SkIPoint16);
 
     // V0
     if (regenPos) {
         SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
         point->fX += transX;
         point->fY += transY;
     }
 
     if (regenCol) {
         SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset);
         *vcolor = color;
     }
 
     if (regenTexCoords) {
-        SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset);
-        textureCoords->set(u0, v0);
+        uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
+        textureCoords[0] = (uint16_t) u0;
+        textureCoords[1] = (uint16_t) v0;
     }
     vertex += vertexStride;
 
     // V1
     if (regenPos) {
         SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
         point->fX += transX;
         point->fY += transY;
     }
 
     if (regenCol) {
         SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset);
         *vcolor = color;
     }
 
     if (regenTexCoords) {
-        SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset);
-        textureCoords->set(u0, v1);
+        uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
+        textureCoords[0] = (uint16_t)u0;
+        textureCoords[1] = (uint16_t)v1;
     }
     vertex += vertexStride;
 
     // V2
     if (regenPos) {
         SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
         point->fX += transX;
         point->fY += transY;
     }
 
     if (regenCol) {
         SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset);
         *vcolor = color;
     }
 
     if (regenTexCoords) {
-        SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset);
-        textureCoords->set(u1, v1);
+        uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
+        textureCoords[0] = (uint16_t)u1;
+        textureCoords[1] = (uint16_t)v1;
     }
     vertex += vertexStride;
 
     // V3
     if (regenPos) {
         SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
         point->fX += transX;
         point->fY += transY;
     }
 
     if (regenCol) {
         SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset);
         *vcolor = color;
     }
 
     if (regenTexCoords) {
-        SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset);
-        textureCoords->set(u1, v0);
+        uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
+        textureCoords[0] = (uint16_t)u1;
+        textureCoords[1] = (uint16_t)v0;
     }
 }
 
 template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
                                    Run* run,
                                    Run::SubRunInfo* info, SkGlyphCache** cache,
                                    SkTypeface** typeface, GrFontScaler** scaler,
@@ skipping 26 matching lines @@
         if (regenGlyphs) {
             strike = fontCache->getStrike(*scaler);
         } else {
             strike = info->strike();
         }
     }
 
     bool brokenRun = false;
     for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
         GrGlyph* glyph = nullptr;
+        int log2Width = 0, log2Height = 0;
         if (regenTexCoords) {
             size_t glyphOffset = glyphIdx + info->glyphStartIndex();
 
             if (regenGlyphs) {
                 // Get the id from the old glyph, and use the new strike to lookup
                 // the glyph.
                 GrGlyph::PackedID id = fGlyphs[glyphOffset]->fPackedID;
                 fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), *scaler);
                 SkASSERT(id == fGlyphs[glyphOffset]->fPackedID);
             }
             glyph = fGlyphs[glyphOffset];
             SkASSERT(glyph && glyph->fMaskFormat == info->maskFormat());
 
             if (!fontCache->hasGlyph(glyph) &&
                 !strike->addGlyphToAtlas(target, glyph, *scaler, info->maskFormat())) {
                 helper->flush();
                 brokenRun = glyphIdx > 0;
 
                 SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                     glyph,
                                                                     *scaler,
                                                                     info->maskFormat());
                 SkASSERT(success);
             }
             fontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph,
                                                     target->currentToken());
+            log2Width = fontCache->log2Width(info->maskFormat());
+            log2Height = fontCache->log2Height(info->maskFormat());
         }
 
         intptr_t vertex = reinterpret_cast<intptr_t>(fVertices);
         vertex += info->vertexStartIndex();
         vertex += vertexStride * glyphIdx * GrAtlasTextBatch::kVerticesPerGlyph;
         regen_vertices<regenPos, regenCol, regenTexCoords>(vertex, glyph, vertexStride,
                                                            info->drawAsDistanceFields(), transX,
-                                                           transY, color);
+                                                           transY, log2Width, log2Height, color);
         helper->incGlyphCount();
     }
 
     // We may have changed the color so update it here
     info->setColor(color);
     if (regenTexCoords) {
         if (regenGlyphs) {
             info->setStrike(strike);
         }
         info->setAtlasGeneration(brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
@@ skipping 82 matching lines @@
             // set use tokens for all of the glyphs in our subrun.  This is only valid if we
             // have a valid atlas generation
             fontCache->setUseTokenBulk(*info.bulkUseToken(), target->currentToken(),
                                         info.maskFormat());
             break;
     }
 
     *byteCount = info.byteCount();
     *vertices = fVertices + info.vertexStartIndex();
 }