Simplify calculations in AADistanceFieldPathBatch::writePathVertices.

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 443 matching lines @@
         SkScalar dy = pathData->fBounds.fTop;
         SkScalar width = pathData->fBounds.width();
         SkScalar height = pathData->fBounds.height();
 
         SkScalar invScale = 1.0f / pathData->fScale;
         dx *= invScale;
         dy *= invScale;
         width *= invScale;
         height *= invScale;
 
-        SkFixed tx = SkIntToFixed(pathData->fAtlasLocation.fX);
-        SkFixed ty = SkIntToFixed(pathData->fAtlasLocation.fY);
-        SkFixed tw = SkScalarToFixed(pathData->fBounds.width());
-        SkFixed th = SkScalarToFixed(pathData->fBounds.height());
-
         SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
 
         // vertex positions
         // TODO make the vertex attributes a struct
         SkRect r = SkRect::MakeXYWH(dx, dy, width, height);
         positions->setRectFan(r.left(), r.top(), r.right(), r.bottom(), vertexStride);
 
         // colors
         for (int i = 0; i < kVerticesPerQuad; i++) {
             GrColor* colorPtr = (GrColor*)(offset + sizeof(SkPoint) + i * vertexStride);
             *colorPtr = color;
         }
 
+        const SkScalar tx = SkIntToScalar(pathData->fAtlasLocation.fX);
+        const SkScalar ty = SkIntToScalar(pathData->fAtlasLocation.fY);
+
         // vertex texture coords
         SkPoint* textureCoords = (SkPoint*)(offset + sizeof(SkPoint) + sizeof(GrColor));
-        textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)),
-                                  SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)),
-                                  SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)),
-                                  SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)),
+        textureCoords->setRectFan(tx / texture->width(),
+                                  ty / texture->height(),
+                                  (tx + pathData->fBounds.width()) / texture->width(),
+                                  (ty + pathData->fBounds.height())  / texture->height(),
                                   vertexStride);
     }
 
     void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
         GrVertices vertices;
         int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
         vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
             flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
             kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
         target->draw(vertices);
@@ skipping 147 matching lines @@
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif