Send less transform data when drawing text with nvpr

src/gpu/GrStencilAndCoverTextContext.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 "GrStencilAndCoverTextContext.h"
 #include "GrDrawTarget.h"
 #include "GrGpu.h"
@@ skipping 133 matching lines @@
     // too. This in turn has the side-effect that NVPR can not stroke the paths,
     // as the stroke in NVPR is defined in object-space.
     // NOTE: here we have following coincidence that works at the moment:
     // - When using the device-space glyphs, the transforms we pass to NVPR
     // instanced drawing are the global transforms, and the view transform is
     // identity. NVPR can not use non-affine transforms in the instanced
     // drawing. This is taken care of by SkDraw::ShouldDrawTextAsPaths since it
     // will turn off the use of device-space glyphs when perspective transforms
     // are in use.
 
-    fGlyphTransform = fContext->getMatrix();
-
-    this->init(paint, skPaint, byteLength);
+    this->init(paint, skPaint, byteLength, kUseIfNeeded_DeviceSpaceGlyphsBehavior);
 
     SkMatrix* glyphCacheTransform = NULL;
     // Transform our starting point.
     if (fNeedsDeviceSpaceGlyphs) {
         SkPoint loc;
-        fGlyphTransform.mapXY(x, y, &loc);
+        fContextInitialMatrix.mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
-        glyphCacheTransform = &fGlyphTransform;
+        glyphCacheTransform = &fContextInitialMatrix;
     }
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
     SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, glyphCacheTransform);
     fGlyphCache = autoCache.getCache();
     fGlyphs = GlyphPathRange::Create(fContext, fGlyphCache, fStroke);
+    fTransformType = GrDrawTarget::kTranslate_PathTransformType;
 
     const char* stop = text + byteLength;
 
     // Measure first if needed.
     if (fSkPaint.getTextAlign() != SkPaint::kLeft_Align) {
         SkFixed    stopX = 0;
         SkFixed    stopY = 0;
 
         const char* textPtr = text;
         while (textPtr < stop) {
@@ skipping 53 matching lines @@
         return;
     }
 
     // This is the fast path.  Here we do not bake in the device-transform to
     // the glyph outline or the advances. This is because we do not need to
     // position the glyphs at all, since the caller has done the positioning.
     // The positioning is based on SkPaint::measureText of individual
     // glyphs. That already uses glyph cache without device transforms. Device
     // transform is not part of SkPaint::measureText API, and thus we use the
     // same glyphs as what were measured.
-    fGlyphTransform.reset();
 
-    this->init(paint, skPaint, byteLength);
+    const float textTranslateY = (1 == scalarsPerPosition ? constY : 0);
+    this->init(paint, skPaint, byteLength, kDoNotUse_DeviceSpaceGlyphsBehavior, textTranslateY);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, NULL);
     fGlyphCache = autoCache.getCache();
     fGlyphs = GlyphPathRange::Create(fContext, fGlyphCache, fStroke);
 
     const char* stop = text + byteLength;
-    SkTextAlignProcScalar alignProc(fSkPaint.getTextAlign());
-    SkTextMapStateProc tmsProc(SkMatrix::I(), constY, scalarsPerPosition);
 
     if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
-        while (text < stop) {
-            SkPoint loc;
-            tmsProc(pos, &loc);
-            const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
-            if (glyph.fWidth) {
-                this->appendGlyph(glyph.getGlyphID(), loc.x(), loc.y());
+        if (1 == scalarsPerPosition) {
+            fTransformType = GrDrawTarget::kTranslateX_PathTransformType;
+            while (text < stop) {
+                const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
+                if (glyph.fWidth) {
+                    this->appendGlyph(glyph.getGlyphID(), *pos);
+                }
+                pos++;
             }
-            pos += scalarsPerPosition;
+        } else {
+            SkASSERT(2 == scalarsPerPosition);
+            fTransformType = GrDrawTarget::kTranslate_PathTransformType;
+            while (text < stop) {
+                const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
+                if (glyph.fWidth) {
+                    this->appendGlyph(glyph.getGlyphID(), pos[0], pos[1]);
+                }
+                pos += 2;
+            }
         }
     } else {
+        fTransformType = GrDrawTarget::kTranslate_PathTransformType;
+        SkTextMapStateProc tmsProc(SkMatrix::I(), 0, scalarsPerPosition);
+        SkTextAlignProcScalar alignProc(fSkPaint.getTextAlign());
         while (text < stop) {
             const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
             if (glyph.fWidth) {
                 SkPoint tmsLoc;
                 tmsProc(pos, &tmsLoc);
                 SkPoint loc;
                 alignProc(tmsLoc, glyph, &loc);
 
                 this->appendGlyph(glyph.getGlyphID(), loc.x(), loc.y());
             }
@@ skipping 23 matching lines @@
     }
 
     // No color bitmap fonts.
     SkScalerContext::Rec    rec;
     SkScalerContext::MakeRec(paint, &fDeviceProperties, NULL, &rec);
     return rec.getFormat() != SkMask::kARGB32_Format;
 }
 
 void GrStencilAndCoverTextContext::init(const GrPaint& paint,
                                         const SkPaint& skPaint,
-                                        size_t textByteLength) {
+                                        size_t textByteLength,
+                                        DeviceSpaceGlyphsBehavior deviceSpaceGlyphsBehavior,
+                                        SkScalar textTranslateY) {
     GrTextContext::init(paint, skPaint);
 
+    fContextInitialMatrix = fContext->getMatrix();
+
     bool otherBackendsWillDrawAsPaths =
-        SkDraw::ShouldDrawTextAsPaths(skPaint, fContext->getMatrix());
+        SkDraw::ShouldDrawTextAsPaths(skPaint, fContextInitialMatrix);
 
     if (otherBackendsWillDrawAsPaths) {
         // This is to reproduce SkDraw::drawText_asPaths glyph positions.
         fSkPaint.setLinearText(true);
         fTextRatio = fSkPaint.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
+        fTextInverseRatio = SkPaint::kCanonicalTextSizeForPaths / fSkPaint.getTextSize();
         fSkPaint.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
         if (fSkPaint.getStyle() != SkPaint::kFill_Style) {
             // Compensate the glyphs being scaled up by fTextRatio by scaling the
             // stroke down.
             fSkPaint.setStrokeWidth(fSkPaint.getStrokeWidth() / fTextRatio);
         }
         fNeedsDeviceSpaceGlyphs = false;
     } else {
-        fTextRatio = 1.0f;
-        fNeedsDeviceSpaceGlyphs = (fGlyphTransform.getType() &
-            (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask)) != 0;
+        fTextRatio = fTextInverseRatio = 1.0f;
+        fNeedsDeviceSpaceGlyphs =
+            kUseIfNeeded_DeviceSpaceGlyphsBehavior == deviceSpaceGlyphsBehavior &&
+            (fContextInitialMatrix.getType() &
+                (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask)) != 0;
         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
-        SkASSERT(!fGlyphTransform.hasPerspective());
-        if (fNeedsDeviceSpaceGlyphs) {
-            fPaint.localCoordChangeInverse(fGlyphTransform);
-            fContext->setIdentityMatrix();
-        }
+        SkASSERT(!fContextInitialMatrix.hasPerspective());
     }
 
     fStroke = SkStrokeRec(fSkPaint);
 
     if (fNeedsDeviceSpaceGlyphs) {
+        SkASSERT(1.0f == fTextRatio);
+        SkASSERT(0.0f == textTranslateY);
+        fPaint.localCoordChangeInverse(fContextInitialMatrix);
+        fContext->setIdentityMatrix();
+
         // The whole shape is baked into the glyph. Make NVPR just fill the
         // baked shape.
         fStroke.setStrokeStyle(-1, false);
     } else {
+        if (1.0f != fTextRatio || 0.0f != textTranslateY) {
+            SkMatrix textMatrix;
+            textMatrix.setTranslate(0, textTranslateY);
+            textMatrix.preScale(fTextRatio, fTextRatio);
+            fPaint.localCoordChange(textMatrix);
+            fContext->concatMatrix(textMatrix);
+        }
+
         if (fSkPaint.getStrokeWidth() == 0.0f) {
             if (fSkPaint.getStyle() == SkPaint::kStrokeAndFill_Style) {
                 fStroke.setStrokeStyle(-1, false);
             } else if (fSkPaint.getStyle() == SkPaint::kStroke_Style) {
                 // Approximate hairline stroke.
                 const SkMatrix& ctm = fContext->getMatrix();
                 SkScalar strokeWidth = SK_Scalar1 /
-                    (fTextRatio * SkVector::Make(ctm.getScaleX(), ctm.getSkewY()).length());
+                    (SkVector::Make(ctm.getScaleX(), ctm.getSkewY()).length());
                 fStroke.setStrokeStyle(strokeWidth, false);
             }
         }
 
         // Make glyph cache produce paths geometry for fill. We will stroke them
         // by passing fStroke to drawPath. This is the fast path.
         fSkPaint.setStyle(SkPaint::kFill_Style);
     }
     fStateRestore.set(fDrawTarget->drawState());
 
     fDrawTarget->drawState()->setFromPaint(fPaint, fContext->getMatrix(),
                                            fContext->getRenderTarget());
 
     GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                  kZero_StencilOp,
                                  kZero_StencilOp,
                                  kNotEqual_StencilFunc,
                                  0xffff,
                                  0x0000,
                                  0xffff);
 
     *fDrawTarget->drawState()->stencil() = kStencilPass;
 
     SkASSERT(0 == fPendingGlyphCount);
 }
 
-inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
+inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x) {
+    SkASSERT(GrDrawTarget::kTranslateX_PathTransformType == fTransformType);
+
     if (fPendingGlyphCount >= kGlyphBufferSize) {
         this->flush();
     }
+
+    fGlyphs->preloadGlyph(glyphID, fGlyphCache);
+
+    fIndexBuffer[fPendingGlyphCount] = glyphID;
+    fTransformBuffer[fPendingGlyphCount] = fTextInverseRatio * x;
+
+    ++fPendingGlyphCount;
+}
+
+inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
+    SkASSERT(GrDrawTarget::kTranslate_PathTransformType == fTransformType);
+
+    if (fPendingGlyphCount >= kGlyphBufferSize) {
+        this->flush();
+    }
 
     fGlyphs->preloadGlyph(glyphID, fGlyphCache);
 
     fIndexBuffer[fPendingGlyphCount] = glyphID;
-    fTransformBuffer[6 * fPendingGlyphCount + 0] = fTextRatio;
-    fTransformBuffer[6 * fPendingGlyphCount + 1] = 0;
-    fTransformBuffer[6 * fPendingGlyphCount + 2] = x;
-    fTransformBuffer[6 * fPendingGlyphCount + 3] = 0;
-    fTransformBuffer[6 * fPendingGlyphCount + 4] = fTextRatio;
-    fTransformBuffer[6 * fPendingGlyphCount + 5] = y;
+    fTransformBuffer[2 * fPendingGlyphCount] = fTextInverseRatio * x;
+    fTransformBuffer[2 * fPendingGlyphCount + 1] = fTextInverseRatio * y;
 
     ++fPendingGlyphCount;
 }
 
 void GrStencilAndCoverTextContext::flush() {
     if (0 == fPendingGlyphCount) {
         return;
     }
 
     fDrawTarget->drawPaths(fGlyphs->pathRange(), fIndexBuffer, fPendingGlyphCount,
-                           fTransformBuffer, GrDrawTarget::kAffine_PathTransformType,
-                           SkPath::kWinding_FillType);
+                           fTransformBuffer, fTransformType, SkPath::kWinding_FillType);
 
     fPendingGlyphCount = 0;
 }
 
 void GrStencilAndCoverTextContext::finish() {
     this->flush();
 
     SkSafeUnref(fGlyphs);
     fGlyphs = NULL;
     fGlyphCache = NULL;
 
     fDrawTarget->drawState()->stencil()->setDisabled();
     fStateRestore.set(NULL);
-    if (fNeedsDeviceSpaceGlyphs) {
-        fContext->setMatrix(fGlyphTransform);
-    }
+    fContext->setMatrix(fContextInitialMatrix);
     GrTextContext::finish();
 }