Calculate translations to apply to vertices in batch

src/gpu/text/GrAtlasTextBlob.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 GrAtlasTextBlob_DEFINED
 #define GrAtlasTextBlob_DEFINED
 
@@ skipping 155 matching lines @@
         switch (maskFormat) {
             case kA8_GrMaskFormat:
                 return kGrayTextVASize;
             case kARGB_GrMaskFormat:
                 return kColorTextVASize;
             default:
                 return kLCDTextVASize;
         }
     }
 
-    bool mustRegenerate(SkScalar* outTransX, SkScalar* outTransY, const SkPaint& paint,
-                        GrColor color, const SkMaskFilter::BlurRec& blurRec,
+    bool mustRegenerate(const SkPaint& paint, GrColor color, const SkMaskFilter::BlurRec& blurRec,
                         const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
 
     // flush a GrAtlasTextBlob associated with a SkTextBlob
     void flushCached(GrContext* context,
                      GrDrawContext* dc,
                      const SkTextBlob* blob,
                      const SkSurfaceProps& props,
                      const GrDistanceFieldAdjustTable* distanceAdjustTable,
                      const SkPaint& skPaint,
                      const GrPaint& grPaint,
                      SkDrawFilter* drawFilter,
                      const GrClip& clip,
                      const SkMatrix& viewMatrix,
                      const SkIRect& clipBounds,
-                     SkScalar x, SkScalar y,
-                     SkScalar transX, SkScalar transY);
+                     SkScalar x, SkScalar y);
 
     // flush a throwaway GrAtlasTextBlob *not* associated with an SkTextBlob
     void flushThrowaway(GrContext* context,
                         GrDrawContext* dc,
                         const SkSurfaceProps& props,
                         const GrDistanceFieldAdjustTable* distanceAdjustTable,
                         const SkPaint& skPaint,
                         const GrPaint& grPaint,
                         const GrClip& clip,
-                        const SkIRect& clipBounds);
+                        const SkMatrix& viewMatrix,
+                        const SkIRect& clipBounds,
+                        SkScalar x, SkScalar y);
 
-    void computeSubRunBounds(SkRect* outBounds, int runIndex, int subRunIndex) {
+    void computeSubRunBounds(SkRect* outBounds, int runIndex, int subRunIndex,
+                             const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         // We don't yet position distance field text on the cpu, so we have to map the vertex bounds
         // into device space.
         // We handle vertex bounds differently for distance field text and bitmap text because
         // the vertex bounds of bitmap text are in device space.  If we are flushing multiple runs
         // from one blob then we are going to pay the price here of mapping the rect for each run.
         const Run& run = fRuns[runIndex];
         const Run::SubRunInfo& subRun = run.fSubRunInfo[subRunIndex];
         *outBounds = subRun.vertexBounds();
         if (subRun.drawAsDistanceFields()) {
             // Distance field text is positioned with the (X,Y) as part of the glyph position,
             // and currently the view matrix is applied on the GPU
-            outBounds->offset(fX - fInitialX, fY - fInitialY);
-            fViewMatrix.mapRect(outBounds);
+            outBounds->offset(x - fInitialX, y - fInitialY);
+            viewMatrix.mapRect(outBounds);
         } else {
             // Bitmap text is fully positioned on the CPU, and offset by an (X,Y) translate in
             // device space.
             SkMatrix boundsMatrix = fInitialViewMatrixInverse;
 
             boundsMatrix.postTranslate(-fInitialX, -fInitialY);
 
-            boundsMatrix.postTranslate(fX, fY);
+            boundsMatrix.postTranslate(x, y);
 
-            boundsMatrix.postConcat(fViewMatrix);
+            boundsMatrix.postConcat(viewMatrix);
             boundsMatrix.mapRect(outBounds);
 
             // Due to floating point numerical inaccuracies, we have to round out here
             outBounds->roundOut(outBounds);
         }
     }
 
-    const SkMatrix& viewMatrix() const { return fViewMatrix; }
-
-
     // position + local coord
     static const size_t kColorTextVASize = sizeof(SkPoint) + sizeof(SkIPoint16);
     static const size_t kGrayTextVASize = sizeof(SkPoint) + sizeof(GrColor) + sizeof(SkIPoint16);
     static const size_t kLCDTextVASize = kGrayTextVASize;
     static const size_t kMaxVASize = kGrayTextVASize;
     static const int kVerticesPerGlyph = 4;
 
     static void AssertEqual(const GrAtlasTextBlob&, const GrAtlasTextBlob&);
 
     // The color here is the GrPaint color, and it is used to determine whether we
     // have to regenerate LCD text blobs.
     // We use this color vs the SkPaint color because it has the colorfilter applied.
     void initReusableBlob(GrColor color, const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         fPaintColor = color;
         this->setupViewMatrix(viewMatrix, x, y);
     }
 
     void initThrowawayBlob(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         this->setupViewMatrix(viewMatrix, x, y);
     }
 
     void regenInBatch(GrDrawBatch::Target* target, GrBatchFontCache* fontCache,
                       GrBlobRegenHelper *helper, int run, int subRun, SkGlyphCache** cache,
                       SkTypeface** typeface, GrFontScaler** scaler,
                       const SkDescriptor** desc, size_t vertexStride,
-                      GrColor color, SkScalar transX, SkScalar transY,
+                      const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+                      GrColor color,
                       void** vertices, size_t* byteCount, int* glyphCount);
 
     const Key& key() const { return fKey; }
 
     ~GrAtlasTextBlob() {
         for (int i = 0; i < fRunCount; i++) {
             fRuns[i].~Run();
         }
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Internal test methods
     GrDrawBatch* test_createBatch(int glyphCount, int run, int subRun,
-                                  GrColor color, SkScalar transX, SkScalar transY,
+                                  const SkMatrix& viewMatrix, SkScalar x, SkScalar y, GrColor color,
                                   const SkPaint& skPaint, const SkSurfaceProps& props,
                                   const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                   GrBatchFontCache* cache);
 
 private:
     GrAtlasTextBlob()
         : fMaxMinScale(-SK_ScalarMax)
         , fMinMaxScale(SK_ScalarMax)
         , fTextType(0) {}
 
     void appendLargeGlyph(GrGlyph* glyph, GrFontScaler* scaler, const SkGlyph& skGlyph,
                           SkScalar x, SkScalar y, SkScalar scale, bool applyVM);
 
     inline void flushRun(GrDrawContext* dc, GrPipelineBuilder* pipelineBuilder,
-                         int run, GrColor color,
-                         SkScalar transX, SkScalar transY,
+                         int run, const SkMatrix& viewMatrix, SkScalar x, SkScalar y, GrColor color,
                          const SkPaint& skPaint, const SkSurfaceProps& props,
                          const GrDistanceFieldAdjustTable* distanceAdjustTable,
                          GrBatchFontCache* cache);
 
     void flushBigGlyphs(GrContext* context, GrDrawContext* dc,
                         const GrClip& clip, const SkPaint& skPaint,
-                        SkScalar transX, SkScalar transY,
+                        const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
                         const SkIRect& clipBounds);
 
     void flushRunAsPaths(GrContext* context,
                          GrDrawContext* dc,
                          const SkSurfaceProps& props,
                          const SkTextBlobRunIterator& it,
                          const GrClip& clip, const SkPaint& skPaint,
                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                          const SkIRect& clipBounds, SkScalar x, SkScalar y);
 
-    // This function will only be called when we are regenerating a blob from scratch. We record the
+    // This function will only be called when we are generating a blob from scratch. We record the
     // initial view matrix and initial offsets(x,y), because we record vertex bounds relative to
     // these numbers.  When blobs are reused with new matrices, we need to return to model space so
     // we can update the vertex bounds appropriately.
     void setupViewMatrix(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
-        fViewMatrix = viewMatrix;
+        fInitialViewMatrix = viewMatrix;
         if (!viewMatrix.invert(&fInitialViewMatrixInverse)) {
             fInitialViewMatrixInverse = SkMatrix::I();
             SkDebugf("Could not invert viewmatrix\n");
         }
-        fX = fInitialX = x;
-        fY = fInitialY = y;
+        fInitialX = x;
+        fInitialY = y;
+
+        // make sure all initial subruns have the correct VM and X/Y applied
+        for (int i = 0; i < fRunCount; i++) {
+            fRuns[i].fSubRunInfo[0].init(fInitialViewMatrix, x, y);
+        }
     }
 
     /*
      * Each Run inside of the blob can have its texture coordinates regenerated if required.
      * To determine if regeneration is necessary, fAtlasGeneration is used.  If there have been
      * any evictions inside of the atlas, then we will simply regenerate Runs.  We could track
      * this at a more fine grained level, but its not clear if this is worth it, as evictions
      * should be fairly rare.
      *
      * One additional point, each run can contain glyphs with any of the three mask formats.
@@ skipping 28 matching lines @@
                 , fGlyphEndIndex(0)
                 , fColor(GrColor_ILLEGAL)
                 , fMaskFormat(kA8_GrMaskFormat)
                 , fDrawAsDistanceFields(false)
                 , fUseLCDText(false) {
                 fVertexBounds.setLargestInverted();
             }
             SubRunInfo(const SubRunInfo& that)
                 : fBulkUseToken(that.fBulkUseToken)
                 , fStrike(SkSafeRef(that.fStrike.get()))
+                , fCurrentViewMatrix(that.fCurrentViewMatrix)
                 , fVertexBounds(that.fVertexBounds)
                 , fAtlasGeneration(that.fAtlasGeneration)
                 , fVertexStartIndex(that.fVertexStartIndex)
                 , fVertexEndIndex(that.fVertexEndIndex)
                 , fGlyphStartIndex(that.fGlyphStartIndex)
                 , fGlyphEndIndex(that.fGlyphEndIndex)
+                , fX(that.fX)
+                , fY(that.fY)
                 , fColor(that.fColor)
                 , fMaskFormat(that.fMaskFormat)
                 , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
                 , fUseLCDText(that.fUseLCDText) {
             }
 
             // TODO when this object is more internal, drop the privacy
             void resetBulkUseToken() { fBulkUseToken.reset(); }
             GrBatchAtlas::BulkUseTokenUpdater* bulkUseToken() { return &fBulkUseToken; }
             void setStrike(GrBatchTextStrike* strike) { fStrike.reset(SkRef(strike)); }
@@ skipping 17 matching lines @@
             GrColor color() const { return fColor; }
             void setMaskFormat(GrMaskFormat format) { fMaskFormat = format; }
             GrMaskFormat maskFormat() const { return fMaskFormat; }
 
             void setAsSuccessor(const SubRunInfo& prev) {
                 fGlyphStartIndex = prev.glyphEndIndex();
                 fGlyphEndIndex = prev.glyphEndIndex();
 
                 fVertexStartIndex = prev.vertexEndIndex();
                 fVertexEndIndex = prev.vertexEndIndex();
+
+                // copy over viewmatrix settings
+                this->init(prev.fCurrentViewMatrix, prev.fX, prev.fY);
             }
 
             const SkRect& vertexBounds() const { return fVertexBounds; }
             void joinGlyphBounds(const SkRect& glyphBounds) {
                 fVertexBounds.joinNonEmptyArg(glyphBounds);
             }
 
+            void init(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
+                fCurrentViewMatrix = viewMatrix;
+                fX = x;
+                fY = y;
+            }
+
+            // This function assumes the translation will be applied before it is called again
+            void computeTranslation(const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+                                    SkScalar*transX, SkScalar* transY);
+
             // df properties
             void setUseLCDText(bool useLCDText) { fUseLCDText = useLCDText; }
             bool hasUseLCDText() const { return fUseLCDText; }
             void setDrawAsDistanceFields() { fDrawAsDistanceFields = true; }
             bool drawAsDistanceFields() const { return fDrawAsDistanceFields; }
 
         private:
             GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
             SkAutoTUnref<GrBatchTextStrike> fStrike;
+            SkMatrix fCurrentViewMatrix;
             SkRect fVertexBounds;
             uint64_t fAtlasGeneration;
             size_t fVertexStartIndex;
             size_t fVertexEndIndex;
             uint32_t fGlyphStartIndex;
             uint32_t fGlyphEndIndex;
+            SkScalar fX;
+            SkScalar fY;
             GrColor fColor;
             GrMaskFormat fMaskFormat;
             bool fDrawAsDistanceFields; // df property
             bool fUseLCDText; // df property
         };
 
         SubRunInfo& push_back() {
             // Forward glyph / vertex information to seed the new sub run
             SubRunInfo& newSubRun = fSubRunInfo.push_back();
             const SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);
@@ skipping 21 matching lines @@
                       GrBlobRegenHelper* helper,
                       Run* run, Run::SubRunInfo* info, SkGlyphCache** cache,
                       SkTypeface** typeface, GrFontScaler** scaler,
                       const SkDescriptor** desc,
                       int glyphCount, size_t vertexStride,
                       GrColor color, SkScalar transX,
                       SkScalar transY) const;
 
     inline GrDrawBatch* createBatch(const Run::SubRunInfo& info,
                                     int glyphCount, int run, int subRun,
-                                    GrColor color, SkScalar transX, SkScalar transY,
+                                    const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
+                                    GrColor color,
                                     const SkPaint& skPaint, const SkSurfaceProps& props,
                                     const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                     GrBatchFontCache* cache);
 
     struct BigGlyph {
         BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool applyVM)
             : fPath(path)
-            , fVx(vx)
-            , fVy(vy)
             , fScale(scale)
+            , fX(vx)
+            , fY(vy)
             , fApplyVM(applyVM) {}
         SkPath fPath;
-        SkScalar fVx;
-        SkScalar fVy;
         SkScalar fScale;
+        SkScalar fX;
+        SkScalar fY;
         bool fApplyVM;
     };
 
     struct StrokeInfo {
         SkScalar fFrameWidth;
         SkScalar fMiterLimit;
         SkPaint::Join fJoin;
     };
 
     enum TextType {
         kHasDistanceField_TextType = 0x1,
         kHasBitmap_TextType = 0x2,
     };
 
     // all glyph / vertex offsets are into these pools.
     unsigned char* fVertices;
     GrGlyph** fGlyphs;
     Run* fRuns;
     GrMemoryPool* fPool;
     SkMaskFilter::BlurRec fBlurRec;
     StrokeInfo fStrokeInfo;
     SkTArray<BigGlyph> fBigGlyphs;
     Key fKey;
-    SkMatrix fViewMatrix;
+    SkMatrix fInitialViewMatrix;
     SkMatrix fInitialViewMatrixInverse;
     size_t fSize;
     GrColor fPaintColor;
     SkScalar fInitialX;
     SkScalar fInitialY;
-    SkScalar fX;
-    SkScalar fY;
 
     // We can reuse distance field text, but only if the new viewmatrix would not result in
     // a mip change.  Because there can be multiple runs in a blob, we track the overall
     // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
     SkScalar fMaxMinScale;
     SkScalar fMinMaxScale;
     int fRunCount;
     uint8_t fTextType;
 };
 
 #endif