GrPathRangeBatch

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"
 #include "GrDrawTarget.h"
 #include "GrPath.h"
 #include "GrPathRange.h"
 #include "GrResourceProvider.h"
 #include "SkAutoKern.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkTextMapStateProc.h"
 #include "SkTextFormatParams.h"
 
+#include "batches/GrDrawPathBatch.h"
+
 GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(GrContext* context,
                                                            const SkSurfaceProps& surfaceProps)
-    : GrTextContext(context, surfaceProps)
-    , fStroke(SkStrokeRec::kFill_InitStyle)
-    , fQueuedGlyphCount(0)
-    , fFallbackGlyphsIdx(kGlyphBufferSize) {
+    : INHERITED(context, surfaceProps)
+    , fDraw(nullptr)
+    , fStroke(SkStrokeRec::kFill_InitStyle) {
 }
 
 GrStencilAndCoverTextContext*
 GrStencilAndCoverTextContext::Create(GrContext* context, const SkSurfaceProps& surfaceProps) {
     GrStencilAndCoverTextContext* textContext = 
         new GrStencilAndCoverTextContext(context, surfaceProps);
     textContext->fFallbackTextContext = GrAtlasTextContext::Create(context, surfaceProps);
 
     return textContext;
 }
@@ skipping 107 matching lines @@
     SkAutoKern autokern;
 
     SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
 
     SkFixed fx = SkScalarToFixed(x);
     SkFixed fy = SkScalarToFixed(y);
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
         fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
-            this->appendGlyph(dc, glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)));
+            this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)));
         }
 
         fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
     }
 
     this->finish(dc);
 }
 
 void GrStencilAndCoverTextContext::onDrawPosText(GrDrawContext* dc, GrRenderTarget* rt,
@@ skipping 33 matching lines @@
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
     SkTextAlignProc 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(dc, glyph, loc);
+            this->appendGlyph(glyph, loc);
         }
         pos += scalarsPerPosition;
     }
 
     this->finish(dc);
 }
 
 static GrPathRange* get_gr_glyphs(GrContext* ctx,
                                   const SkTypeface* typeface,
                                   const SkDescriptor* desc,
@@ skipping 169 matching lines @@
         }
         inverse->preScale(1, -1);
     } else {
         inverse->setScale(1, -1);
         const SkMatrix& unflip = *inverse; // unflip is equal to its own inverse.
         fViewMatrix.preConcat(unflip);
     }
     return true;
 }
 
-inline void GrStencilAndCoverTextContext::appendGlyph(GrDrawContext* dc,
-                                                      const SkGlyph& glyph,
-                                                      const SkPoint& pos) {
-    if (fQueuedGlyphCount >= fFallbackGlyphsIdx) {
-        SkASSERT(fQueuedGlyphCount == fFallbackGlyphsIdx);
-        this->flush(dc);
+inline void GrStencilAndCoverTextContext::appendGlyph(const SkGlyph& glyph, const SkPoint& pos) {
+    // Stick the glyphs we can't draw into the fallback arrays.
+    if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
+        fFallbackIndices.push_back(glyph.getGlyphID());
+        fFallbackPositions.push_back().set(fTextInverseRatio * pos.x(),
+                                           -fTextInverseRatio * pos.y());
+    } else {
+        // TODO: infer the reserve count from the text length.
+        if (!fDraw) {
+            fDraw = GrPathRangeDraw::Create(fGlyphs,
+                                            GrPathRendering::kTranslate_PathTransformType,
+                                            64);
+        }
+        float translate[] = { fTextInverseRatio * pos.x(), -fTextInverseRatio * pos.y() };
+        fDraw->append(glyph.getGlyphID(), translate);
     }
-
-    // Stick the glyphs we can't draw at the end of the buffer, growing backwards.
-    int index = (SkMask::kARGB32_Format == glyph.fMaskFormat) ?
-                --fFallbackGlyphsIdx : fQueuedGlyphCount++;
-
-    fGlyphIndices[index] = glyph.getGlyphID();
-    fGlyphPositions[index].set(fTextInverseRatio * pos.x(), -fTextInverseRatio * pos.y());
 }
 
 static const SkScalar* get_xy_scalar_array(const SkPoint* pointArray) {
     GR_STATIC_ASSERT(2 * sizeof(SkScalar) == sizeof(SkPoint));
     GR_STATIC_ASSERT(0 == offsetof(SkPoint, fX));
 
     return &pointArray[0].fX;
 }
 
 void GrStencilAndCoverTextContext::flush(GrDrawContext* dc) {
-    if (fQueuedGlyphCount > 0) {
+    if (fDraw) {
+        SkASSERT(fDraw->count());
         SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(fPaint.getColor(),
                                                                  fViewMatrix,
                                                                  fLocalMatrix));
 
         // We should only be flushing about once every run.  However, if this impacts performance
         // we could move the creation of the GrPipelineBuilder earlier.
         GrPipelineBuilder pipelineBuilder(fPaint, fRenderTarget, fClip);
         SkASSERT(fRenderTarget->isStencilBufferMultisampled() || !fPaint.isAntiAlias());
         pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, fPaint.isAntiAlias());
 
         GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                      kZero_StencilOp,
                                      kKeep_StencilOp,
                                      kNotEqual_StencilFunc,
                                      0xffff,
                                      0x0000,
                                      0xffff);
 
         *pipelineBuilder.stencil() = kStencilPass;
 
-        SkASSERT(kGlyphBufferSize == fFallbackGlyphsIdx);
-
-        dc->drawPaths(&pipelineBuilder, pp, fGlyphs,
-                      fGlyphIndices, GrPathRange::kU16_PathIndexType,
-                      get_xy_scalar_array(fGlyphPositions),
-                      GrPathRendering::kTranslate_PathTransformType,
-                      fQueuedGlyphCount, GrPathRendering::kWinding_FillType);
-
-        fQueuedGlyphCount = 0;
+        dc->drawPathsFromRange(&pipelineBuilder, pp, fDraw, GrPathRendering::kWinding_FillType);
+        fDraw->unref();
+        fDraw = nullptr;
     }
 
-    if (fFallbackGlyphsIdx < kGlyphBufferSize) {
-        int fallbackGlyphCount = kGlyphBufferSize - fFallbackGlyphsIdx;
-
+    if (fFallbackIndices.count()) {
+        SkASSERT(fFallbackPositions.count() == fFallbackIndices.count());
         GrPaint paintFallback(fPaint);
 
         SkPaint skPaintFallback(fSkPaint);
         if (!fUsingDeviceSpaceGlyphs) {
             fStroke.applyToPaint(&skPaintFallback);
         }
         skPaintFallback.setTextAlign(SkPaint::kLeft_Align); // Align has already been accounted for.
         skPaintFallback.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
         SkMatrix inverse;
         if (this->mapToFallbackContext(&inverse)) {
-            inverse.mapPoints(&fGlyphPositions[fFallbackGlyphsIdx], fallbackGlyphCount);
+            inverse.mapPoints(fFallbackPositions.begin(), fFallbackPositions.count());
         }
 
         fFallbackTextContext->drawPosText(dc, fRenderTarget, fClip, paintFallback, skPaintFallback,
-                                          fViewMatrix, (char*)&fGlyphIndices[fFallbackGlyphsIdx],
-                                          2 * fallbackGlyphCount,
-                                          get_xy_scalar_array(&fGlyphPositions[fFallbackGlyphsIdx]),
+                                          fViewMatrix, (char*)fFallbackIndices.begin(),
+                                          sizeof(uint16_t) * fFallbackIndices.count(),
+                                          get_xy_scalar_array(fFallbackPositions.begin()),
                                           2, SkPoint::Make(0, 0), fRegionClipBounds);
-
-        fFallbackGlyphsIdx = kGlyphBufferSize;
+        fFallbackIndices.reset();
+        fFallbackPositions.reset();
     }
 }
 
 void GrStencilAndCoverTextContext::finish(GrDrawContext* dc) {
     this->flush(dc);
 
+    SkASSERT(!fDraw);
+    SkASSERT(!fFallbackIndices.count());
+    SkASSERT(!fFallbackPositions.count());
+
     fGlyphs->unref();
     fGlyphs = nullptr;
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = nullptr;
 
     fViewMatrix = fContextInitialMatrix;
 }
-