Remove 1d glyph positions from nvpr text

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 "GrBitmapTextContext.h"
 #include "GrDrawTarget.h"
@@ skipping 70 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.
 
-    this->init(paint, skPaint, byteLength, kMaxAccuracy_RenderMode, SkPoint::Make(0, 0));
+    this->init(paint, skPaint, byteLength, kMaxAccuracy_RenderMode);
 
     // Transform our starting point.
     if (fNeedsDeviceSpaceGlyphs) {
         SkPoint loc;
         fContextInitialMatrix.mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
     }
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
-    fTransformType = GrPathRendering::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) {
             // We don't need x, y here, since all subpixel variants will have the
@@ skipping 53 matching lines @@
     }
 
     // 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.
 
-    this->init(paint, skPaint, byteLength, kMaxPerformance_RenderMode, offset);
+    this->init(paint, skPaint, byteLength, kMaxPerformance_RenderMode);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     const char* stop = text + byteLength;
 
-    if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
-        if (1 == scalarsPerPosition) {
-            fTransformType = GrPathRendering::kTranslateX_PathTransformType;
-            while (text < stop) {
-                const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
-                if (glyph.fWidth) {
-                    this->appendGlyph(glyph.getGlyphID(), *pos);
-                }
-                pos++;
-            }
-        } else {
-            SkASSERT(2 == scalarsPerPosition);
-            fTransformType = GrPathRendering::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;
-            }
+    SkTextMapStateProc tmsProc(SkMatrix::I(), offset, 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());
         }
-    } else {
-        fTransformType = GrPathRendering::kTranslate_PathTransformType;
-        SkTextMapStateProc tmsProc(SkMatrix::I(), SkPoint::Make(0, 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());
-            }
-            pos += scalarsPerPosition;
-        }
+        pos += scalarsPerPosition;
     }
 
     this->finish();
 }
 
 static GrPathRange* get_gr_glyphs(GrContext* ctx,
                                   const SkTypeface* typeface,
                                   const SkDescriptor* desc,
                                   const SkStrokeRec& stroke) {
     static const GrCacheID::Domain gGlyphsDomain = GrCacheID::GenerateDomain();
@@ skipping 12 matching lines @@
         glyphs.reset(ctx->getGpu()->pathRendering()->createGlyphs(typeface, desc, stroke));
         ctx->addResourceToCache(resourceKey, glyphs);
     }
 
     return glyphs.detach();
 }
 
 void GrStencilAndCoverTextContext::init(const GrPaint& paint,
                                         const SkPaint& skPaint,
                                         size_t textByteLength,
-                                        RenderMode renderMode,
-                                        const SkPoint& textTranslate) {
+                                        RenderMode renderMode) {
     GrTextContext::init(paint, skPaint);
 
     fContextInitialMatrix = fContext->getMatrix();
 
     const bool otherBackendsWillDrawAsPaths =
         SkDraw::ShouldDrawTextAsPaths(skPaint, fContextInitialMatrix);
 
     fNeedsDeviceSpaceGlyphs = !otherBackendsWillDrawAsPaths &&
                               kMaxAccuracy_RenderMode == renderMode &&
                               SkToBool(fContextInitialMatrix.getType() &
                                        (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask));
 
     if (fNeedsDeviceSpaceGlyphs) {
         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
         SkASSERT(!fContextInitialMatrix.hasPerspective());
-        SkASSERT(textTranslate.isZero()); // TODO: Handle textTranslate in device-space usecase.
 
         fTextRatio = fTextInverseRatio = 1.0f;
 
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         SkMatrix m;
         m.setScale(1, -1);
         fContext->setMatrix(m);
 
         // Post-flip the initial matrix so we're left with just the flip after
         // the paint preConcats the inverse.
@@ skipping 61 matching lines @@
             canUseRawPaths = SK_Scalar1 == fSkPaint.getTextScaleX() &&
                              0 == fSkPaint.getTextSkewX() &&
                              !fSkPaint.isFakeBoldText() &&
                              !fSkPaint.isVerticalText();
         } else {
             fTextRatio = fTextInverseRatio = 1.0f;
             canUseRawPaths = false;
         }
 
         SkMatrix textMatrix;
-        textMatrix.setTranslate(textTranslate.x(), textTranslate.y());
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
-        textMatrix.preScale(fTextRatio, -fTextRatio);
+        textMatrix.setScale(fTextRatio, -fTextRatio);
         fPaint.localCoordChange(textMatrix);
         fContext->concatMatrix(textMatrix);
 
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, NULL, false);
         fGlyphs = canUseRawPaths ?
                       get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, gpuStroke) :
                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                     &fGlyphCache->getDescriptor(), gpuStroke);
     }
 
     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) {
-    SkASSERT(GrPathRendering::kTranslateX_PathTransformType == fTransformType);
-
+inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
     if (fPendingGlyphCount >= kGlyphBufferSize) {
         this->flush();
     }
-
-    fIndexBuffer[fPendingGlyphCount] = glyphID;
-    fTransformBuffer[fPendingGlyphCount] = fTextInverseRatio * x;
-
-    ++fPendingGlyphCount;
-}
-
-inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
-    SkASSERT(GrPathRendering::kTranslate_PathTransformType == fTransformType);
-
-    if (fPendingGlyphCount >= kGlyphBufferSize) {
-        this->flush();
-    }
 
     fIndexBuffer[fPendingGlyphCount] = glyphID;
     fTransformBuffer[2 * fPendingGlyphCount] = fTextInverseRatio * x;
     fTransformBuffer[2 * fPendingGlyphCount + 1] = -fTextInverseRatio * y;
 
     ++fPendingGlyphCount;
 }
 
 void GrStencilAndCoverTextContext::flush() {
     if (0 == fPendingGlyphCount) {
         return;
     }
 
-    fDrawTarget->drawPaths(fGlyphs, fIndexBuffer, fPendingGlyphCount,
-                           fTransformBuffer, fTransformType, GrPathRendering::kWinding_FillType);
+    fDrawTarget->drawPaths(fGlyphs, fIndexBuffer, fPendingGlyphCount, fTransformBuffer,
+                           GrPathRendering::kTranslate_PathTransformType,
+                           GrPathRendering::kWinding_FillType);
 
     fPendingGlyphCount = 0;
 }
 
 void GrStencilAndCoverTextContext::finish() {
     this->flush();
 
     fGlyphs->unref();
     fGlyphs = NULL;
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fDrawTarget->drawState()->stencil()->setDisabled();
     fStateRestore.set(NULL);
     fContext->setMatrix(fContextInitialMatrix);
     GrTextContext::finish();
 }