Start caching masks / stroke fills for textblobs

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 42 matching lines @@
         case kARGB_GrMaskFormat:
             return kColorTextVASize;
         default:
             return kLCDTextVASize;
     }
 }
 
 };
 
 // TODO
-// More tests
-// move to SkCache
-// handle textblobs where the whole run is larger than the cache size
-// TODO implement micro speedy hash map for fast refing of glyphs
+// Gamma slotting to preserve color
+// Better reuse on regeneration
+// Telemetry tests
+// possibly consider having a regeneration ratio on the textblob itself for animated textblobs
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
                                        SkGpuDevice* gpuDevice,
                                        const SkDeviceProperties& properties)
     : INHERITED(context, gpuDevice, properties) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
     SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
                       vertex_attribute_changed);
     fCurrStrike = NULL;
     fCache = context->getTextBlobCache();
 }
 
 GrAtlasTextContext* GrAtlasTextContext::Create(GrContext* context,
                                                SkGpuDevice* gpuDevice,
                                                const SkDeviceProperties& props) {
     return SkNEW_ARGS(GrAtlasTextContext, (context, gpuDevice, props));
 }
 
 bool GrAtlasTextContext::canDraw(const GrRenderTarget*,
                                  const GrClip&,
                                  const GrPaint&,
                                  const SkPaint& skPaint,
                                  const SkMatrix& viewMatrix) {
     return !SkDraw::ShouldDrawTextAsPaths(skPaint, viewMatrix);
 }
 
 bool GrAtlasTextContext::MustRegenerateBlob(SkScalar* outTransX, SkScalar* outTransY,
                                             const BitmapTextBlob& blob, const SkPaint& paint,
+                                            const SkMaskFilter::BlurRec& blurRec,
                                             const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
     // Color can affect the mask
     // TODO we can adjust the color within specific gamma slots
     if (blob.fColor != paint.getColor()) {
         return true;
     }
 
     if (blob.fViewMatrix.hasPerspective() != viewMatrix.hasPerspective()) {
         return true;
     }
 
     if (blob.fViewMatrix.hasPerspective() && !blob.fViewMatrix.cheapEqualTo(viewMatrix)) {
         return true;
     }
 
     if (blob.fViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
         blob.fViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
         blob.fViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
         blob.fViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
         return true;
     }
 
+    // We only cache one masked version
+    if (blob.fKey.fHasBlur &&
+        (blob.fBlurRec.fSigma != blurRec.fSigma ||
+         blob.fBlurRec.fStyle != blurRec.fStyle ||
+         blob.fBlurRec.fQuality != blurRec.fQuality)) {
+        return true;
+    }
+
+    // Similarly, we only cache one version for each style
+    if (blob.fKey.fStyle != SkPaint::kFill_Style &&
+        (blob.fStrokeInfo.fFrameWidth != paint.getStrokeWidth() ||
+         blob.fStrokeInfo.fMiterLimit != paint.getStrokeMiter() ||
+         blob.fStrokeInfo.fJoin != paint.getStrokeJoin())) {
+        return true;
+    }
+
     // We can update the positions in the cachedtextblobs without regenerating the whole blob, but
     // only for integer translations.
     // This cool bit of math will determine the necessary translation to apply to the already
     // generated vertex coordinates to move them to the correct position
     SkScalar transX = viewMatrix.getTranslateX() +
                       viewMatrix.getScaleX() * (x - blob.fX) +
                       viewMatrix.getSkewX() * (y - blob.fY) -
                       blob.fViewMatrix.getTranslateX();
     SkScalar transY = viewMatrix.getTranslateY() +
                       viewMatrix.getSkewY() * (x - blob.fX) +
@@ skipping 27 matching lines @@
                                                     const SkMatrix& viewMatrix) {
     skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, &viewMatrix, false);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
     return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
 }
 
 void GrAtlasTextContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
                                       const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                       const SkTextBlob* blob, SkScalar x, SkScalar y,
                                       SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
-    uint32_t uniqueID = blob->uniqueID();
     SkAutoTUnref<BitmapTextBlob> cacheBlob;
-    // TODO start caching these, mix bits into the key
+
+    SkMaskFilter::BlurRec blurRec;
+    BitmapTextBlob::Key key;
+    // It might be worth caching these things, but its not clear at this time
+    // TODO for animated mask filters, this will fill up our cache.  We need a safeguard here
+    const SkMaskFilter* mf = skPaint.getMaskFilter();
     bool canCache = !(skPaint.getPathEffect() ||
-                      skPaint.getMaskFilter() ||
-                      skPaint.getColorFilter() ||
-                      skPaint.getStyle() != SkPaint::kFill_Style ||
+                      (mf && !mf->asABlur(&blurRec)) ||
                       drawFilter);
 
     if (canCache) {
-        cacheBlob.reset(SkSafeRef(fCache->find(uniqueID)));
+        key.fUniqueID = blob->uniqueID();
+        key.fStyle = skPaint.getStyle();
+        key.fHasBlur = SkToBool(mf);
+        cacheBlob.reset(SkSafeRef(fCache->find(key)));
     }
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     SkScalar transX = 0.f;
     SkScalar transY = 0.f;
 
     if (cacheBlob) {
-        if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, viewMatrix, x, y)) {
+        if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, blurRec, viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
             fCache->remove(cacheBlob);
-            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, kGrayTextVASize)));
+            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
+                                                           kGrayTextVASize)));
             this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter,
                                      clipRect);
         } else {
             // If we can reuse the blob, then make sure we update the blob's viewmatrix and x/y
             // offsets to reflect the results of any translations we may apply in generateGeometry
             cacheBlob->fViewMatrix = viewMatrix;
             cacheBlob->fX = x;
             cacheBlob->fY = y;
             fCache->makeMRU(cacheBlob);
         }
     } else {
         if (canCache) {
-            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, kGrayTextVASize)));
+            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
+                                                           kGrayTextVASize)));
         } else {
             cacheBlob.reset(fCache->createBlob(blob, kGrayTextVASize));
         }
         this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter, clipRect);
     }
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     SkPaint2GrPaintShader(fContext, rt, skPaint, viewMatrix, true, &grPaint);
 
     this->flush(fContext->getTextTarget(), blob, cacheBlob, rt, skPaint, grPaint, drawFilter,
                 clip, viewMatrix, clipBounds, x, y, transX, transY);
 }
 
 void GrAtlasTextContext::regenerateTextBlob(BitmapTextBlob* cacheBlob,
                                             const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                                             SkDrawFilter* drawFilter, const SkIRect& clipRect) {
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
     cacheBlob->fColor = skPaint.getColor();
-    cacheBlob->fStyle = skPaint.getStyle();
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         int glyphCount = it.glyphCount();
         size_t textLen = glyphCount * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint for this reason.
@@ skipping 57 matching lines @@
 void GrAtlasTextContext::onDrawText(GrRenderTarget* rt, const GrClip& clip,
                                     const GrPaint& paint, const SkPaint& skPaint,
                                     const SkMatrix& viewMatrix,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
     int glyphCount = skPaint.countText(text, byteLength);
     SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
     blob->fViewMatrix = viewMatrix;
     blob->fX = x;
     blob->fY = y;
-    blob->fStyle = skPaint.getStyle();
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
     this->internalDrawText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, x, y, clipRect);
     SkGlyphCache::AttachCache(cache);
 
     this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip, viewMatrix);
@@ skipping 90 matching lines @@
 }
 
 void GrAtlasTextContext::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
                                        const GrPaint& paint, const SkPaint& skPaint,
                                        const SkMatrix& viewMatrix,
                                        const char text[], size_t byteLength,
                                        const SkScalar pos[], int scalarsPerPosition,
                                        const SkPoint& offset, const SkIRect& regionClipBounds) {
     int glyphCount = skPaint.countText(text, byteLength);
     SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
-    blob->fStyle = skPaint.getStyle();
     blob->fViewMatrix = viewMatrix;
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
     this->internalDrawPosText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, pos,
                               scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
@@ skipping 784 matching lines @@
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha, 0, 0);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }