Improve nvpr glyph batching

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 "GrAtlasTextContext.h"
 #include "GrDrawContext.h"
@@ skipping 215 matching lines @@
         }
 
         fCpuMemorySize += run->computeSizeInCache();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class GrStencilAndCoverTextContext::FallbackBlobBuilder {
 public:
-    FallbackBlobBuilder() : fBuffIdx(0) {}
+    FallbackBlobBuilder() : fBuffIdx(0), fCount(0) {}
 
     bool isInitialized() const { return SkToBool(fBuilder); }
 
     void init(const SkPaint& font, SkScalar textRatio);
 
     void appendGlyph(uint16_t glyphId, const SkPoint& pos);
 
-    const SkTextBlob* buildIfInitialized();
+    const SkTextBlob* buildIfNeeded(int* count);
 
 private:
     enum { kWriteBufferSize = 1024 };
 
     void flush();
 
     SkAutoTDelete<SkTextBlobBuilder>   fBuilder;
     SkPaint                            fFont;
     int                                fBuffIdx;
+    int                                fCount;
     uint16_t                           fGlyphIds[kWriteBufferSize];
     SkPoint                            fPositions[kWriteBufferSize];
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
     : fStroke(fontAndStroke),
       fFont(fontAndStroke),
       fTotalGlyphCount(0),
+      fFallbackGlyphCount(0),
       fDetachedGlyphCache(nullptr),
       fLastDrawnGlyphsID(SK_InvalidUniqueID) {
     SkASSERT(!fStroke.isHairlineStyle()); // Hairlines are not supported.
 
     // Setting to "fill" ensures that no strokes get baked into font outlines. (We use the GPU path
     // rendering API for stroking).
     fFont.setStyle(SkPaint::kFill_Style);
 
     if (fFont.isFakeBoldText() && SkStrokeRec::kStroke_Style != fStroke.getStyle()) {
         // Instead of letting fake bold get baked into the glyph outlines, do it with GPU stroke.
@@ skipping 58 matching lines @@
             const SkDescriptor* desc = &glyphCache->getDescriptor();
             int descDataCount = (desc->getLength() + 3) / 4;
             GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain,
                                          2 + strokeDataCount + descDataCount);
             reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
             reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount | (descDataCount << 16);
             fStroke.asUniqueKeyFragment(&builder[2]);
             memcpy(&builder[2 + strokeDataCount], desc, desc->getLength());
         }
     }
-
-    // When drawing from canonically sized paths, the actual local coords are fTextRatio * coords.
-    fLocalMatrixTemplate.setScale(fTextRatio, fTextRatio);
 }
 
 GrStencilAndCoverTextContext::TextRun::~TextRun() {
     this->releaseGlyphCache();
 }
 
 void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t byteLength,
                                                     SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     SkGlyphCache* glyphCache = this->getGlyphCache();
     SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
 
-    fDraw.reset(GrPathRangeDraw::Create(GrPathRendering::kTranslate_PathTransformType,
-                                        fTotalGlyphCount = fFont.countText(text, byteLength)));
+    fTotalGlyphCount = fFont.countText(text, byteLength);
+    fInstanceData.reset(InstanceData::Alloc(GrPathRendering::kTranslate_PathTransformType,
+                                            fTotalGlyphCount));
 
     const char* stop = text + byteLength;
 
     // Measure first if needed.
     if (fFont.getTextAlign() != SkPaint::kLeft_Align) {
         SkFixed    stopX = 0;
         SkFixed    stopY = 0;
 
         const char* textPtr = text;
         while (textPtr < stop) {
@@ skipping 30 matching lines @@
         fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
             this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)),
                               &fallback);
         }
 
         fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
     }
 
-    fFallbackTextBlob.reset(fallback.buildIfInitialized());
+    fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
 }
 
 void GrStencilAndCoverTextContext::TextRun::setPosText(const char text[], size_t byteLength,
                                                        const SkScalar pos[], int scalarsPerPosition,
                                                        const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     SkGlyphCache* glyphCache = this->getGlyphCache();
     SkDrawCacheProc glyphCacheProc = fFont.getDrawCacheProc();
 
-    fDraw.reset(GrPathRangeDraw::Create(GrPathRendering::kTranslate_PathTransformType,
-                                        fTotalGlyphCount = fFont.countText(text, byteLength)));
+    fTotalGlyphCount = fFont.countText(text, byteLength);
+    fInstanceData.reset(InstanceData::Alloc(GrPathRendering::kTranslate_PathTransformType,
+                                            fTotalGlyphCount));
 
     const char* stop = text + byteLength;
 
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
     SkTextAlignProc alignProc(fFont.getTextAlign());
     FallbackBlobBuilder fallback;
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(glyphCache, &text, 0, 0);
         if (glyph.fWidth) {
             SkPoint tmsLoc;
             tmsProc(pos, &tmsLoc);
             SkPoint loc;
             alignProc(tmsLoc, glyph, &loc);
 
             this->appendGlyph(glyph, loc, &fallback);
         }
         pos += scalarsPerPosition;
     }
 
-    fFallbackTextBlob.reset(fallback.buildIfInitialized());
+    fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
 }
 
 GrPathRange* GrStencilAndCoverTextContext::TextRun::createGlyphs(GrContext* ctx) const {
     GrPathRange* glyphs = static_cast<GrPathRange*>(
             ctx->resourceProvider()->findAndRefResourceByUniqueKey(fGlyphPathsKey));
     if (nullptr == glyphs) {
         if (fUsingRawGlyphPaths) {
             glyphs = ctx->resourceProvider()->createGlyphs(fFont.getTypeface(), nullptr, fStroke);
         } else {
             SkGlyphCache* cache = this->getGlyphCache();
             glyphs = ctx->resourceProvider()->createGlyphs(cache->getScalerContext()->getTypeface(),
                                                            &cache->getDescriptor(),
                                                            fStroke);
         }
         ctx->resourceProvider()->assignUniqueKeyToResource(fGlyphPathsKey, glyphs);
     }
     return glyphs;
 }
 
 inline void GrStencilAndCoverTextContext::TextRun::appendGlyph(const SkGlyph& glyph,
                                                                const SkPoint& pos,
                                                                FallbackBlobBuilder* fallback) {
     // Stick the glyphs we can't draw into the fallback text blob.
     if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
         if (!fallback->isInitialized()) {
             fallback->init(fFont, fTextRatio);
         }
         fallback->appendGlyph(glyph.getGlyphID(), pos);
     } else {
-        float translate[] = { fTextInverseRatio * pos.x(), fTextInverseRatio * pos.y() };
-        fDraw->append(glyph.getGlyphID(), translate);
+        fInstanceData->append(glyph.getGlyphID(), fTextInverseRatio * pos.x(),
+                              fTextInverseRatio * pos.y());
     }
 }
 
 void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx,
                                                  GrDrawContext* dc,
                                                  GrPipelineBuilder* pipelineBuilder,
                                                  GrColor color,
                                                  const SkMatrix& viewMatrix,
                                                  SkScalar x, SkScalar y,
                                                  const SkIRect& clipBounds,
                                                  GrTextContext* fallbackTextContext,
                                                  const SkPaint& originalSkPaint) const {
-    SkASSERT(fDraw);
+    SkASSERT(fInstanceData);
     SkASSERT(dc->accessRenderTarget()->isStencilBufferMultisampled() || !fFont.isAntiAlias());
 
-    if (fDraw->count()) {
+    if (fInstanceData->count()) {
         pipelineBuilder->setState(GrPipelineBuilder::kHWAntialias_Flag, fFont.isAntiAlias());
 
         GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                      kZero_StencilOp,
                                      kKeep_StencilOp,
                                      kNotEqual_StencilFunc,
                                      0xffff,
                                      0x0000,
                                      0xffff);
 
         *pipelineBuilder->stencil() = kStencilPass;
 
         SkAutoTUnref<GrPathRange> glyphs(this->createGlyphs(ctx));
         if (fLastDrawnGlyphsID != glyphs->getUniqueID()) {
             // Either this is the first draw or the glyphs object was purged since last draw.
-            glyphs->loadPathsIfNeeded(fDraw->indices(), fDraw->count());
+            glyphs->loadPathsIfNeeded(fInstanceData->indices(), fInstanceData->count());
             fLastDrawnGlyphsID = glyphs->getUniqueID();
         }
 
-        SkMatrix drawMatrix(viewMatrix);
-        drawMatrix.preTranslate(x, y);
-        drawMatrix.preScale(fTextRatio, fTextRatio);
-
-        SkMatrix& localMatrix = fLocalMatrixTemplate;
-        localMatrix.setTranslateX(x);
-        localMatrix.setTranslateY(y);
-
         // Don't compute a bounding box. For dst copy texture, we'll opt instead for it to just copy
         // the entire dst. Realistically this is a moot point, because any context that supports
         // NV_path_rendering will also support NV_blend_equation_advanced.
         // For clipping we'll just skip any optimizations based on the bounds. This does, however,
         // hurt batching.
         SkRect bounds = SkRect::MakeIWH(pipelineBuilder->getRenderTarget()->width(),
                                         pipelineBuilder->getRenderTarget()->height());
 
         SkAutoTUnref<GrDrawPathBatchBase> batch(
-            GrDrawPathRangeBatch::Create(drawMatrix, localMatrix, color,
-                                         GrPathRendering::kWinding_FillType, glyphs, fDraw,
+            GrDrawPathRangeBatch::Create(viewMatrix, fTextRatio, fTextInverseRatio * x,
+                                         fTextInverseRatio * y, color,
+                                         GrPathRendering::kWinding_FillType, glyphs, fInstanceData,
                                          bounds));
 
         dc->drawPathBatch(*pipelineBuilder, batch);
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStroke.applyToPaint(&fallbackSkPaint);
         if (!fStroke.isFillStyle()) {
             fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
@@ skipping 13 matching lines @@
 
 
 void GrStencilAndCoverTextContext::TextRun::releaseGlyphCache() const {
     if (fDetachedGlyphCache) {
         SkGlyphCache::AttachCache(fDetachedGlyphCache);
         fDetachedGlyphCache = nullptr;
     }
 }
 
 size_t GrStencilAndCoverTextContext::TextRun::computeSizeInCache() const {
-    size_t size = sizeof(TextRun) +
-               fGlyphPathsKey.size() +
-               fTotalGlyphCount * (sizeof(uint16_t) + 2 * sizeof(float));
-    if (fDraw) {
-        size += sizeof(GrPathRangeDraw);
+    size_t size = sizeof(TextRun) + fGlyphPathsKey.size();
+    // The instance data always reserves enough space for every glyph.
+    size += (fTotalGlyphCount + fFallbackGlyphCount) * (sizeof(uint16_t) + 2 * sizeof(float));
+    if (fInstanceData) {
+        size += sizeof(InstanceData);
     }
     if (fFallbackTextBlob) {
         size += sizeof(SkTextBlob);
     }
     return size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void GrStencilAndCoverTextContext::FallbackBlobBuilder::init(const SkPaint& font,
@@ skipping 12 matching lines @@
 
 void GrStencilAndCoverTextContext::FallbackBlobBuilder::appendGlyph(uint16_t glyphId,
                                                                     const SkPoint& pos) {
     SkASSERT(this->isInitialized());
     if (fBuffIdx >= kWriteBufferSize) {
         this->flush();
     }
     fGlyphIds[fBuffIdx] = glyphId;
     fPositions[fBuffIdx] = pos;
     fBuffIdx++;
+    fCount++;
 }
 
 void GrStencilAndCoverTextContext::FallbackBlobBuilder::flush() {
     SkASSERT(this->isInitialized());
     SkASSERT(fBuffIdx <= kWriteBufferSize);
     if (!fBuffIdx) {
         return;
     }
     // This will automatically merge with previous runs since we use the same font.
     const SkTextBlobBuilder::RunBuffer& buff = fBuilder->allocRunPos(fFont, fBuffIdx);
     memcpy(buff.glyphs, fGlyphIds, fBuffIdx * sizeof(uint16_t));
     memcpy(buff.pos, fPositions[0].asScalars(), fBuffIdx * 2 * sizeof(SkScalar));
     fBuffIdx = 0;
 }
 
-const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfInitialized() {
-    if (!this->isInitialized()) {
-        return nullptr;
+const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfNeeded(int *count) {
+    *count = fCount;
+    if (fCount) {
+        this->flush();
+        return fBuilder->build();
     }
-    this->flush();
-    return fBuilder->build();
+    return nullptr;
 }