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 122 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 {

[Chris Dalton, 2014/07/18 22:23:30]

We could do a translate-x here too if we could verify every glyph's advanceY
will be zero. That seems to be the usual case, is there a way to know they will
all be zero?

[jvanverth1, 2014/07/21 17:23:13]

Not sure -- adding bungeman to see if he knows.

[bungeman-skia, 2014/07/21 17:51:27]

I'm not sure I understand. You've used scalersPerPosition above which when 1
means there are just x advances. Is that what you want? It's an odd way to
phrase the question as the glyph advances don't really mean anything here, its
just glyphs at positions (the advances were probably used to generate those
positions, but they might not have been).

+        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();
 }