Calculate translations to apply to vertices in batch

src/gpu/batches/GrAtlasTextBatch.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlasTextBatch_DEFINED
 #define GrAtlasTextBatch_DEFINED
 
 #include "batches/GrVertexBatch.h"
 
 #include "text/GrAtlasTextContext.h"
 #include "text/GrDistanceFieldAdjustTable.h"
 
 class GrAtlasTextBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     static const int kVerticesPerGlyph = GrAtlasTextBlob::kVerticesPerGlyph;
     static const int kIndicesPerGlyph = 6;
 
     typedef GrAtlasTextBlob Blob;
     struct Geometry {
+        SkMatrix fViewMatrix;
         Blob* fBlob;
+        SkScalar fX;
+        SkScalar fY;
         int fRun;
         int fSubRun;
         GrColor fColor;
-        SkScalar fTransX;
-        SkScalar fTransY;
     };
 
     static GrAtlasTextBatch* CreateBitmap(GrMaskFormat maskFormat, int glyphCount,
                                           GrBatchFontCache* fontCache) {
         GrAtlasTextBatch* batch = new GrAtlasTextBatch;
 
         batch->fFontCache = fontCache;
         switch (maskFormat) {
             case kA8_GrMaskFormat:
                 batch->fMaskType = kGrayscaleCoverageMask_MaskType;
@@ skipping 31 matching lines @@
     }
 
     // to avoid even the initial copy of the struct, we have a getter for the first item which
     // is used to seed the batch with its initial geometry.  After seeding, the client should call
     // init() so the Batch can initialize itself
     Geometry& geometry() { return fGeoData[0]; }
 
     void init() {
         const Geometry& geo = fGeoData[0];
         fBatch.fColor = geo.fColor;
-        fBatch.fViewMatrix = geo.fBlob->viewMatrix();
 
-        geo.fBlob->computeSubRunBounds(&fBounds, geo.fRun, geo.fSubRun);
+        geo.fBlob->computeSubRunBounds(&fBounds, geo.fRun, geo.fSubRun, geo.fViewMatrix, geo.fX,
+                                       geo.fY);
     }
 
     const char* name() const override { return "TextBatch"; }
 
     SkString dumpInfo() const override;
 
 protected:
     void computePipelineOptimizations(GrInitInvariantOutput* color, 
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override;
@@ skipping 39 matching lines @@
     }
 
     bool isLCD() const {
         return kLCDCoverageMask_MaskType == fMaskType ||
                kLCDDistanceField_MaskType == fMaskType;
     }
 
     inline void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const;
 
     GrColor color() const { return fBatch.fColor; }
-    const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
+    const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     int numGlyphs() const { return fBatch.fNumGlyphs; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override;
 
     // TODO just use class params
     // TODO trying to figure out why lcd is so whack
     GrGeometryProcessor* setupDfProcessor(const SkMatrix& viewMatrix, SkColor filteredColor,
                                           GrColor color, GrTexture* texture) const;
 
     struct BatchTracker {
         GrColor fColor;
-        SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         int fNumGlyphs;
     };
 
     BatchTracker fBatch;
     // The minimum number of Geometry we will try to allocate.
     enum { kMinGeometryAllocated = 4 };
     SkAutoSTMalloc<kMinGeometryAllocated, Geometry> fGeoData;
@@ skipping 41 matching lines @@
     }
 
 private:
     const GrAtlasTextBatch* fBatch;
     GrVertexBatch::Target* fTarget;
     GrAtlasTextBatch::FlushInfo* fFlushInfo;
     const GrGeometryProcessor* fGP;
 };
 
 #endif