Glyph positions maintain 32 bit integer part.

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 "GrDefaultGeoProcFactory.h"
@@ skipping 120 matching lines @@
         numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
     }
     fTotalVertexCount = kVerticesPerGlyph*numGlyphs;
 
     const char* stop = text + byteLength;
 
     SkAutoKern autokern;
 
     SkFixed fxMask = ~0;
     SkFixed fyMask = ~0;
-    SkFixed halfSampleX, halfSampleY;
+    SkScalar halfSampleX, halfSampleY;
     if (cache->isSubpixel()) {
-        halfSampleX = halfSampleY = SkGlyph::kSubpixelRound;
+        halfSampleX = halfSampleY = SkFixedToScalar(SkGlyph::kSubpixelRound);
         SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(viewMatrix);
         if (kX_SkAxisAlignment == baseline) {
             fyMask = 0;
-            halfSampleY = SK_FixedHalf;
+            halfSampleY = SK_ScalarHalf;
         } else if (kY_SkAxisAlignment == baseline) {
             fxMask = 0;
-            halfSampleX = SK_FixedHalf;
+            halfSampleX = SK_ScalarHalf;
         }
     } else {
-        halfSampleX = halfSampleY = SK_FixedHalf;
+        halfSampleX = halfSampleY = SK_ScalarHalf;
     }
 
-    SkFixed fx = SkScalarToFixed(x) + halfSampleX;
-    SkFixed fy = SkScalarToFixed(y) + halfSampleY;
+    Sk48Dot16 fx = SkScalarTo48Dot16(x + halfSampleX);
+    Sk48Dot16 fy = SkScalarTo48Dot16(y + halfSampleY);
 
     // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix, but for
     // performance reasons we just invert here instead
     if (!viewMatrix.invert(&fLocalMatrix)) {
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }
 
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(cache, &text, fx & fxMask, fy & fyMask);
 
         fx += autokern.adjust(glyph);
 
         if (glyph.fWidth) {
             this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                             glyph.getSubXFixed(),
                                             glyph.getSubYFixed()),
-                              SkFixedFloorToFixed(fx),
-                              SkFixedFloorToFixed(fy),
+                              Sk48Dot16FloorToInt(fx),
+                              Sk48Dot16FloorToInt(fy),
                               fontScaler);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
 
     this->finish();
 }
 
@@ skipping 25 matching lines @@
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }
 
     int numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
     fTotalVertexCount = kVerticesPerGlyph*numGlyphs;
 
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(fSkPaint.getTextAlign());
     SkTextMapStateProc tmsProc(viewMatrix, offset, scalarsPerPosition);
-    SkFixed halfSampleX = 0, halfSampleY = 0;
+    SkScalar halfSampleX = 0, halfSampleY = 0;
 
     if (cache->isSubpixel()) {
         // maybe we should skip the rounding if linearText is set
         SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(viewMatrix);
 
         SkFixed fxMask = ~0;
         SkFixed fyMask = ~0;
         if (kX_SkAxisAlignment == baseline) {
             fyMask = 0;
-            halfSampleY = SK_FixedHalf;
+            halfSampleY = SK_ScalarHalf;
         } else if (kY_SkAxisAlignment == baseline) {
             fxMask = 0;
-            halfSampleX = SK_FixedHalf;
+            halfSampleX = SK_ScalarHalf;
         }
 
         if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
             while (text < stop) {
                 SkPoint tmsLoc;
                 tmsProc(pos, &tmsLoc);
-                SkFixed fx = SkScalarToFixed(tmsLoc.fX) + halfSampleX;
-                SkFixed fy = SkScalarToFixed(tmsLoc.fY) + halfSampleY;
+                Sk48Dot16 fx = SkScalarTo48Dot16(tmsLoc.fX + halfSampleX);
+                Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + halfSampleY);
 
                 const SkGlyph& glyph = glyphCacheProc(cache, &text,
                                                       fx & fxMask, fy & fyMask);
 
                 if (glyph.fWidth) {
                     this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed()),
-                                      SkFixedFloorToFixed(fx),
-                                      SkFixedFloorToFixed(fy),
+                                      Sk48Dot16FloorToInt(fx),
+                                      Sk48Dot16FloorToInt(fy),
                                       fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
                 const char* currentText = text;
                 const SkGlyph& metricGlyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (metricGlyph.fWidth) {
                     SkDEBUGCODE(SkFixed prevAdvX = metricGlyph.fAdvanceX;)
                     SkDEBUGCODE(SkFixed prevAdvY = metricGlyph.fAdvanceY;)
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
-                    SkIPoint fixedLoc;
-                    alignProc(tmsLoc, metricGlyph, &fixedLoc);
+                    SkPoint alignLoc;
+                    alignProc(tmsLoc, metricGlyph, &alignLoc);
 
-                    SkFixed fx = fixedLoc.fX + halfSampleX;
-                    SkFixed fy = fixedLoc.fY + halfSampleY;
+                    Sk48Dot16 fx = SkScalarTo48Dot16(alignLoc.fX + halfSampleX);
+                    Sk48Dot16 fy = SkScalarTo48Dot16(alignLoc.fY + halfSampleY);
 
                     // have to call again, now that we've been "aligned"
                     const SkGlyph& glyph = glyphCacheProc(cache, &currentText,
                                                           fx & fxMask, fy & fyMask);
                     // the assumption is that the metrics haven't changed
                     SkASSERT(prevAdvX == glyph.fAdvanceX);
                     SkASSERT(prevAdvY == glyph.fAdvanceY);
                     SkASSERT(glyph.fWidth);
 
                     this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed()),
-                                      SkFixedFloorToFixed(fx),
-                                      SkFixedFloorToFixed(fy),
+                                      Sk48Dot16FloorToInt(fx),
+                                      Sk48Dot16FloorToInt(fy),
                                       fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         }
     } else {    // not subpixel
 
         if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
-                    SkFixed fx = SkScalarToFixed(tmsLoc.fX) + SK_FixedHalf; //halfSampleX;
-                    SkFixed fy = SkScalarToFixed(tmsLoc.fY) + SK_FixedHalf; //halfSampleY;
+                    Sk48Dot16 fx = SkScalarTo48Dot16(tmsLoc.fX + SK_ScalarHalf); //halfSampleX;
+                    Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed()),
-                                      SkFixedFloorToFixed(fx),
-                                      SkFixedFloorToFixed(fy),
+                                      Sk48Dot16FloorToInt(fx),
+                                      Sk48Dot16FloorToInt(fy),
                                       fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
-                    SkIPoint fixedLoc;
-                    alignProc(tmsLoc, glyph, &fixedLoc);
+                    SkPoint alignLoc;
+                    alignProc(tmsLoc, glyph, &alignLoc);
 
-                    SkFixed fx = fixedLoc.fX + SK_FixedHalf; //halfSampleX;
-                    SkFixed fy = fixedLoc.fY + SK_FixedHalf; //halfSampleY;
+                    Sk48Dot16 fx = SkScalarTo48Dot16(alignLoc.fX + SK_ScalarHalf); //halfSampleX;
+                    Sk48Dot16 fy = SkScalarTo48Dot16(alignLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed()),
-                                      SkFixedFloorToFixed(fx),
-                                      SkFixedFloorToFixed(fy),
+                                      Sk48Dot16FloorToInt(fx),
+                                      Sk48Dot16FloorToInt(fy),
                                       fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
 
     this->finish();
 }
 
@@ skipping 55 matching lines @@
         }
         
         // we should never get here
         SkASSERT(false);
     }
     
     return false;
 }
 
 void GrBitmapTextContext::appendGlyph(GrGlyph::PackedID packed,
-                                      SkFixed vx, SkFixed vy,
+                                      int vx, int vy,
                                       GrFontScaler* scaler) {
     if (NULL == fDrawTarget) {
         return;
     }
 
     if (NULL == fStrike) {
         fStrike = fContext->getFontCache()->getStrike(scaler, false);
     }
 
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
-    vx += SkIntToFixed(glyph->fBounds.fLeft);
-    vy += SkIntToFixed(glyph->fBounds.fTop);
+    int x = vx + glyph->fBounds.fLeft;
+    int y = vy + glyph->fBounds.fTop;
 
     // keep them as ints until we've done the clip-test
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
     // check if we clipped out
-    int x = vx >> 16;
-    int y = vy >> 16;
     if (fClipRect.quickReject(x, y, x + width, y + height)) {
         return;
     }
 
     // If the glyph is too large we fall back to paths
     if (NULL == glyph->fPlot && !uploadGlyph(glyph, scaler)) {
         if (NULL == glyph->fPath) {
             SkPath* path = SkNEW(SkPath);
             if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                 // flag the glyph as being dead?
                 delete path;
                 return;
             }
             glyph->fPath = path;
         }
 
         // flush any accumulated draws before drawing this glyph as a path.
         this->flush();
 
         SkMatrix translate;
-        translate.setTranslate(SkFixedToScalar(vx - SkIntToFixed(glyph->fBounds.fLeft)),
-                               SkFixedToScalar(vy - SkIntToFixed(glyph->fBounds.fTop)));
+        translate.setTranslate(SkIntToScalar(vx), SkIntToScalar(vy));
         SkPath tmpPath(*glyph->fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(fRenderTarget, fClip, fPaint, SkMatrix::I(), tmpPath, strokeInfo);
 
         // remove this glyph from the vertices we need to allocate
         fTotalVertexCount -= kVerticesPerGlyph;
         return;
     }
 
@@ skipping 12 matching lines @@
         fCurrMaskFormat = glyph->fMaskFormat;
     }
 
     if (NULL == fVertices) {
         int maxQuadVertices = kVerticesPerGlyph * fContext->getQuadIndexBuffer()->maxQuads();
         fAllocVertexCount = SkMin32(fTotalVertexCount, maxQuadVertices);
         fVertices = alloc_vertices(fDrawTarget, fAllocVertexCount, fCurrMaskFormat);
     }
 
     SkRect r;
-    r.fLeft = SkFixedToFloat(vx);
-    r.fTop = SkFixedToFloat(vy);
-    r.fRight = r.fLeft + width;
-    r.fBottom = r.fTop + height;
+    r.fLeft = SkIntToScalar(x);
+    r.fTop = SkIntToScalar(y);
+    r.fRight = r.fLeft + SkIntToScalar(width);
+    r.fBottom = r.fTop + SkIntToScalar(height);
 
     fVertexBounds.joinNonEmptyArg(r);
-    
+
     int u0 = glyph->fAtlasLocation.fX;
     int v0 = glyph->fAtlasLocation.fY;
     int u1 = u0 + width;
     int v1 = v0 + height;
 
     size_t vertSize = get_vertex_stride(fCurrMaskFormat);
     intptr_t vertex = reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex;
 
     // V0
     SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fTop);
     if (kA8_GrMaskFormat == fCurrMaskFormat) {
         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;
-    
+
     // V1
     position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fBottom);
     if (kA8_GrMaskFormat == fCurrMaskFormat) {
         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(r.fRight, r.fBottom);
     if (kA8_GrMaskFormat == fCurrMaskFormat) {
         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(r.fRight, r.fTop);
     if (kA8_GrMaskFormat == fCurrMaskFormat) {
         SkColor* color = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *color = fPaint.getColor();
     }
     textureCoords = reinterpret_cast<SkIPoint16*>(vertex + vertSize  - sizeof(SkIPoint16));
     textureCoords->set(u1, v0);
 
@@ skipping 77 matching lines @@
     }
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }