Add stroking support to distance field path renderer

src/gpu/batches/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 66 matching lines @@
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
 
     // TODO: Support inverse fill
-    // TODO: Support strokes
     if (!args.fShaderCaps->shaderDerivativeSupport() || !args.fAntiAlias ||
-        args.fPath->isInverseFillType() || args.fPath->isVolatile() ||
-        !args.fStroke->isFillStyle()) {
+        SkStrokeRec::kHairline_Style == args.fStroke->getStyle() ||
+        args.fPath->isInverseFillType() || args.fPath->isVolatile()) {
         return false;
     }
 
     // currently don't support perspective
     if (args.fViewMatrix->hasPerspective()) {
         return false;
     }
     
-    // only support paths smaller than 64x64, scaled to less than 256x256
+    // only support paths smaller than kMediumMIP by kMediumMIP,
+    // scaled to less than 2.0f*kLargeMIP by 2.0f*kLargeMIP
     // the goal is to accelerate rendering of lots of small paths that may be scaling
     SkScalar maxScale = args.fViewMatrix->getMaxScale();
     const SkRect& bounds = args.fPath->getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());

[robertphillips, 2015/11/19 19:03:28]

// Outset by half the stroke width when stroking
?

if (SkStrokeRect::kFill_Stype != args.fStroke->getStyle())
?

Don't we have to take into account the mitre limit too in some cases ?

[jvanverth1, 2015/11/19 20:33:23]

Done.

-    return maxDim < 64.f && maxDim * maxScale < 256.f;
+    if (SkStrokeRec::kStroke_Style == args.fStroke->getStyle() ||
+        SkStrokeRec::kStrokeAndFill_Style == args.fStroke->getStyle()) {
+        maxDim += args.fStroke->getWidth()*0.5f;
+    }
+    
+    return maxDim < kMediumMIP && maxDim * maxScale < 2.0f*kLargeMIP;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // padding around path bounds to allow for antialiased pixels
 static const SkScalar kAntiAliasPad = 1.0f;
 
 class AADistanceFieldPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     typedef GrAADistanceFieldPathRenderer::PathData PathData;
     typedef SkTDynamicHash<PathData, PathData::Key> PathCache;
     typedef GrAADistanceFieldPathRenderer::PathDataList PathDataList;
 
     struct Geometry {
         Geometry(const SkStrokeRec& stroke) : fStroke(stroke) {}
         SkPath fPath;

[robertphillips, 2015/11/19 19:03:28]

// The unique ID of the path involved in this draw. This may be different than
the unique ID in 'fPath' since that path may have resulted from a
SkStrokeRec::applyToPath call.

?

[jvanverth1, 2015/11/19 20:33:23]

Done.

+        uint32_t fGenID;
         SkStrokeRec fStroke;
         bool fAntiAlias;
         PathData* fPathData;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                                GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
         return new AADistanceFieldPathBatch(geometry, color, viewMatrix, atlas, pathCache,
                                             pathList);
     }
@@ skipping 85 matching lines @@
             uint32_t desiredDimension;
             if (size <= kSmallMIP) {
                 desiredDimension = kSmallMIP;
             } else if (size <= kMediumMIP) {
                 desiredDimension = kMediumMIP;
             } else {
                 desiredDimension = kLargeMIP;
             }
 
             // check to see if path is cached
-            // TODO: handle stroked vs. filled version of same path
-            PathData::Key key = { args.fPath.getGenerationID(), desiredDimension };
+            PathData::Key key(args.fGenID, desiredDimension, args.fStroke);
             args.fPathData = fPathCache->find(key);
             if (nullptr == args.fPathData || !atlas->hasID(args.fPathData->fID)) {
                 // Remove the stale cache entry
                 if (args.fPathData) {
                     fPathCache->remove(args.fPathData->fKey);
                     fPathList->remove(args.fPathData);
                     delete args.fPathData;
                 }
                 SkScalar scale = desiredDimension/maxDim;
                 args.fPathData = new PathData;
                 if (!this->addPathToAtlas(target,
                                           dfProcessor,
                                           this->pipeline(),
                                           &flushInfo,
                                           atlas,
                                           args.fPathData,
                                           args.fPath,
+                                          args.fGenID,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
             atlas->setLastUseToken(args.fPathData->fID, target->currentToken());
@@ skipping 37 matching lines @@
         viewMatrix.mapRect(&fBounds);
     }
 
     bool addPathToAtlas(GrVertexBatch::Target* target,
                         const GrGeometryProcessor* dfProcessor,
                         const GrPipeline* pipeline,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
                         const SkPath& path,
-                        const SkStrokeRec&
-                        stroke, bool antiAlias,
+                        uint32_t genID,
+                        const SkStrokeRec& stroke,
+                        bool antiAlias,
                         uint32_t dimension,
                         SkScalar scale) {
         const SkRect& bounds = path.getBounds();
 
         // generate bounding rect for bitmap draw
         SkRect scaledBounds = bounds;
         // scale to mip level size
         scaledBounds.fLeft *= scale;
         scaledBounds.fTop *= scale;
         scaledBounds.fRight *= scale;
@@ skipping 10 matching lines @@
         // move origin to upper left corner
         devPathBounds.offsetTo(0,0);
 
         // draw path to bitmap
         SkMatrix drawMatrix;
         drawMatrix.setTranslate(-bounds.left(), -bounds.top());
         drawMatrix.postScale(scale, scale);
         drawMatrix.postTranslate(kAntiAliasPad, kAntiAliasPad);
 
         // setup bitmap backing
-        // Now translate so the bound's UL corner is at the origin
-        drawMatrix.postTranslate(-devPathBounds.fLeft * SK_Scalar1,
-                                 -devPathBounds.fTop * SK_Scalar1);
-        SkIRect pathBounds = SkIRect::MakeWH(devPathBounds.width(),
-                                             devPathBounds.height());
-
+        SkASSERT(devPathBounds.fLeft == 0);
+        SkASSERT(devPathBounds.fTop == 0);
         SkAutoPixmapStorage dst;
-        if (!dst.tryAlloc(SkImageInfo::MakeA8(pathBounds.width(),
-                                              pathBounds.height()))) {
+        if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(),
+                                              devPathBounds.height()))) {
             return false;
         }
         sk_bzero(dst.writable_addr(), dst.getSafeSize());
 
         // rasterize path
         SkPaint paint;
-        if (stroke.isHairlineStyle()) {
-            paint.setStyle(SkPaint::kStroke_Style);
-            paint.setStrokeWidth(SK_Scalar1);
-        } else {
-            if (stroke.isFillStyle()) {
-                paint.setStyle(SkPaint::kFill_Style);
-            } else {
-                paint.setStyle(SkPaint::kStroke_Style);
-                paint.setStrokeJoin(stroke.getJoin());
-                paint.setStrokeCap(stroke.getCap());
-                paint.setStrokeWidth(stroke.getWidth());
-            }
-        }
+        paint.setStyle(SkPaint::kFill_Style);
         paint.setAntiAlias(antiAlias);
 
         SkDraw draw;
         sk_bzero(&draw, sizeof(draw));
 
         SkRasterClip rasterClip;
-        rasterClip.setRect(pathBounds);
+        rasterClip.setRect(devPathBounds);
         draw.fRC = &rasterClip;
         draw.fClip = &rasterClip.bwRgn();
         draw.fMatrix = &drawMatrix;
         draw.fDst = dst;
 
         draw.drawPathCoverage(path, paint);
 
         // generate signed distance field
         devPathBounds.outset(SK_DistanceFieldPad, SK_DistanceFieldPad);
         int width = devPathBounds.width();
@@ skipping 15 matching lines @@
             this->flush(target, flushInfo);
             target->initDraw(dfProcessor, pipeline);
 
             SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height,
                                                      dfStorage.get(), &atlasLocation);
             SkASSERT(success);
 
         }
 
         // add to cache
-        pathData->fKey.fGenID = path.getGenerationID();
-        pathData->fKey.fDimension = dimension;
+        pathData->fKey = PathData::Key(genID, dimension, stroke);
         pathData->fScale = scale;
         pathData->fID = id;
         // change the scaled rect to match the size of the inset distance field
         scaledBounds.fRight = scaledBounds.fLeft +
             SkIntToScalar(devPathBounds.width() - 2*SK_DistanceFieldInset);
         scaledBounds.fBottom = scaledBounds.fTop +
             SkIntToScalar(devPathBounds.height() - 2*SK_DistanceFieldInset);
         // shift the origin to the correct place relative to the distance field
         // need to also restore the fractional translation
         scaledBounds.offset(-SkIntToScalar(SK_DistanceFieldInset) - kAntiAliasPad + dx,
@@ skipping 118 matching lines @@
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &GrAADistanceFieldPathRenderer::HandleEviction,
                                                      (void*)this);
         if (!fAtlas) {
             return false;
         }
     }
 
     AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
-    geometry.fPath = *args.fPath;
+    if (SkStrokeRec::kFill_Style == args.fStroke->getStyle()) {
+        geometry.fPath = *args.fPath;
+    } else {

[robertphillips, 2015/11/19 19:03:28]

Do we need 'newPath'? Can't we pass "&geometry.fPath" into applyToPath ?

[jvanverth1, 2015/11/19 20:33:23]

Done.

+        SkPath newPath;
+        args.fStroke->applyToPath(&newPath, *args.fPath);
+        geometry.fPath = newPath;
+    }
     geometry.fAntiAlias = args.fAntiAlias;

[robertphillips, 2015/11/19 19:03:28]

// Note: this is the generation ID of the _original_ path. When a new path is
generated due to stroking it is important that the original path's id is used
for caching.

[jvanverth1, 2015/11/19 20:33:23]

Done.

-
+    geometry.fGenID = args.fPath->getGenerationID();
+ 
     SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
                                                                      *args.fViewMatrix, fAtlas,
                                                                      &fPathCache, &fPathList));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 62 matching lines @@
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif