Improve caching of dashed paths in GrStencilAndCoverPathRenderer

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 "GrDrawTarget.h"
@@ skipping 37 matching lines @@
                                            const GrClip& clip,
                                            const GrPaint& paint,
                                            const SkPaint& skPaint,
                                            const SkMatrix& viewMatrix) {
     if (skPaint.getRasterizer()) {
         return false;
     }
     if (skPaint.getMaskFilter()) {
         return false;
     }
-    if (skPaint.getPathEffect()) {
-        return false;
+    if (SkPathEffect* pe = skPaint.getPathEffect()) {
+        if (pe->asADash(NULL) != SkPathEffect::kDash_DashType) {
+            return false;
+        }
     }
 
     // No hairlines unless we can map the 1 px width to the object space.
     if (skPaint.getStyle() == SkPaint::kStroke_Style
         && skPaint.getStrokeWidth() == 0
         && viewMatrix.hasPerspective()) {
         return false;
     }
 
     // No color bitmap fonts.
@@ skipping 143 matching lines @@
         }
         pos += scalarsPerPosition;
     }
 
     this->finish();
 }
 
 static GrPathRange* get_gr_glyphs(GrContext* ctx,
                                   const SkTypeface* typeface,
                                   const SkDescriptor* desc,
-                                  const SkStrokeRec& stroke) {
+                                  const GrStrokeInfo& stroke) {
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 4);
     struct GlyphKey {
         uint32_t fChecksum;
         uint32_t fTypeface;
         uint64_t fStroke;
     };
     GlyphKey* glyphKey = reinterpret_cast<GlyphKey*>(&builder[0]);
     glyphKey->fChecksum = desc ? desc->getChecksum() : 0;
@@ skipping 32 matching lines @@
                               kMaxAccuracy_RenderMode == renderMode &&
                               SkToBool(fContextInitialMatrix.getType() &
                                        (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask));
 
     if (fUsingDeviceSpaceGlyphs) {
         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
         SkASSERT(!fContextInitialMatrix.hasPerspective());
 
         // The whole shape (including stroke) will be baked into the glyph outlines. Make
         // NVPR just fill the baked shapes.
-        fStroke = SkStrokeRec(SkStrokeRec::kFill_InitStyle);
+        fStroke = GrStrokeInfo(SkStrokeRec::kFill_InitStyle);
 
         fTextRatio = fTextInverseRatio = 1.0f;
 
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         SkMatrix m;
         m.setScale(1, -1);
         fViewMatrix = m;
 
         // Post-flip the initial matrix so we're left with just the flip after
         // the paint preConcats the inverse.
         m = fContextInitialMatrix;
         m.postScale(1, -1);
         if (!m.invert(&fLocalMatrix)) {
             SkDebugf("Not invertible!\n");
             return;
         }
 
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, &fContextInitialMatrix,
                                            true /*ignoreGamma*/);
         fGlyphs = get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                 &fGlyphCache->getDescriptor(), fStroke);
     } else {
         // Don't bake strokes into the glyph outlines. We will stroke the glyphs
         // using the GPU instead. This is the fast path.
-        fStroke = SkStrokeRec(fSkPaint);
+        fStroke = GrStrokeInfo(fSkPaint);
+        SkStrokeRec* strokeRec = fStroke.getStrokeRecPtr();
         fSkPaint.setStyle(SkPaint::kFill_Style);
 
-        if (fStroke.isHairlineStyle()) {
+        if (strokeRec->isHairlineStyle()) {
             // Approximate hairline stroke.
             SkScalar strokeWidth = SK_Scalar1 /
                 (SkVector::Make(fContextInitialMatrix.getScaleX(),
                                 fContextInitialMatrix.getSkewY()).length());
-            fStroke.setStrokeStyle(strokeWidth, false /*strokeAndFill*/);
+            strokeRec->setStrokeStyle(strokeWidth, false /*strokeAndFill*/);
 
         } else if (fSkPaint.isFakeBoldText() &&
 #ifdef SK_USE_FREETYPE_EMBOLDEN
                    kMaxPerformance_RenderMode == renderMode &&
 #endif
-                   SkStrokeRec::kStroke_Style != fStroke.getStyle()) {
+                   SkStrokeRec::kStroke_Style != strokeRec->getStyle()) {
 
             // Instead of baking fake bold into the glyph outlines, do it with the GPU stroke.
             SkScalar fakeBoldScale = SkScalarInterpFunc(fSkPaint.getTextSize(),
                                                         kStdFakeBoldInterpKeys,
                                                         kStdFakeBoldInterpValues,
                                                         kStdFakeBoldInterpLength);
             SkScalar extra = SkScalarMul(fSkPaint.getTextSize(), fakeBoldScale);
-            fStroke.setStrokeStyle(fStroke.needToApply() ? fStroke.getWidth() + extra : extra,
+            strokeRec->setStrokeStyle(strokeRec->needToApply() ? strokeRec->getWidth() + extra : extra,
                                    true /*strokeAndFill*/);
 
             fSkPaint.setFakeBoldText(false);
         }
 
         bool canUseRawPaths;
-
-        if (otherBackendsWillDrawAsPaths || kMaxPerformance_RenderMode == renderMode) {
+        if (!fStroke.isDashed() && (otherBackendsWillDrawAsPaths || kMaxPerformance_RenderMode == renderMode)) {

[egdaniel, 2015/05/05 19:48:44]

100 chars

[Kimmo Kinnunen, 2015/05/06 08:30:25]

Done.

             // We can draw the glyphs from canonically sized paths.
             fTextRatio = fSkPaint.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
             fTextInverseRatio = SkPaint::kCanonicalTextSizeForPaths / fSkPaint.getTextSize();
 
             // Compensate for the glyphs being scaled by fTextRatio.
-            if (!fStroke.isFillStyle()) {
-                fStroke.setStrokeStyle(fStroke.getWidth() / fTextRatio,
-                                       SkStrokeRec::kStrokeAndFill_Style == fStroke.getStyle());
+            if (!strokeRec->isFillStyle()) {
+                strokeRec->setStrokeStyle(strokeRec->getWidth() / fTextRatio,
+                                       SkStrokeRec::kStrokeAndFill_Style == strokeRec->getStyle());
             }
 
             fSkPaint.setLinearText(true);
             fSkPaint.setLCDRenderText(false);
             fSkPaint.setAutohinted(false);
             fSkPaint.setHinting(SkPaint::kNo_Hinting);
             fSkPaint.setSubpixelText(true);
             fSkPaint.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
 
             canUseRawPaths = SK_Scalar1 == fSkPaint.getTextScaleX() &&
@@ skipping 91 matching lines @@
         fQueuedGlyphCount = 0;
     }
 
     if (fFallbackGlyphsIdx < kGlyphBufferSize) {
         int fallbackGlyphCount = kGlyphBufferSize - fFallbackGlyphsIdx;
 
         GrPaint paintFallback(fPaint);
 
         SkPaint skPaintFallback(fSkPaint);
         if (!fUsingDeviceSpaceGlyphs) {
-            fStroke.applyToPaint(&skPaintFallback);
+            fStroke.getStrokeRecPtr()->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);
         }
 
         fFallbackTextContext->drawPosText(fRenderTarget, fClip, paintFallback, skPaintFallback,
@@ skipping 14 matching lines @@
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fPipelineBuilder.stencil()->setDisabled();
     fStateRestore.set(NULL);
     fViewMatrix = fContextInitialMatrix;
     GrTextContext::finish();
 }