Generate Signed Distance Field directly from vector path

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
+ * Copyright 2016 ARM Ltd.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrContext.h"
 #include "GrPipelineBuilder.h"
 #include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "GrSWMaskHelper.h"
 #include "GrTexturePriv.h"
 #include "GrVertexBuffer.h"
 #include "batches/GrVertexBatch.h"
 #include "effects/GrDistanceFieldGeoProc.h"
 
 #include "SkDistanceFieldGen.h"
+#include "GrDistanceFieldGenFromVector.h"
 #include "SkRTConf.h"
 
 #define ATLAS_TEXTURE_WIDTH 2048
 #define ATLAS_TEXTURE_HEIGHT 2048
 #define PLOT_WIDTH  512
 #define PLOT_HEIGHT 256
 
 #define NUM_PLOTS_X   (ATLAS_TEXTURE_WIDTH / PLOT_WIDTH)
 #define NUM_PLOTS_Y   (ATLAS_TEXTURE_HEIGHT / PLOT_HEIGHT)
 
@@ skipping 53 matching lines @@
     if (!args.fShaderCaps->shaderDerivativeSupport() || !args.fAntiAlias ||
         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 with bounds within kMediumMIP by kMediumMIP,
     // scaled to have bounds within 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());
     // Approximate stroked size by adding the maximum of the stroke width or 2x the miter limit
     if (!args.fStroke->isFillStyle()) {
         SkScalar extraWidth = args.fStroke->getWidth();
         if (SkPaint::kMiter_Join == args.fStroke->getJoin()) {
             extraWidth = SkTMax(extraWidth, 2.0f*args.fStroke->getMiter());
         }
         maxDim += extraWidth;
     }
-    
+
     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:
@@ skipping 23 matching lines @@
         bool fAntiAlias;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
                                GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
         return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, pathCache, pathList);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
-    void computePipelineOptimizations(GrInitInvariantOutput* color, 
+    void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
         overrides->fUsePLSDstRead = false;
     }
 
 private:
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
@@ skipping 184 matching lines @@
         devPathBounds.fRight = intPad + width;
         devPathBounds.fBottom = intPad + height;
         devPathBounds.outset(intPad, intPad);
 
         // draw path to bitmap
         SkMatrix drawMatrix;
         drawMatrix.setTranslate(-bounds.left(), -bounds.top());
         drawMatrix.postScale(scale, scale);
         drawMatrix.postTranslate(kAntiAliasPad, kAntiAliasPad);
 
-        // setup bitmap backing
         SkASSERT(devPathBounds.fLeft == 0);
         SkASSERT(devPathBounds.fTop == 0);
-        SkAutoPixmapStorage dst;
-        if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(),
-                                              devPathBounds.height()))) {
-            return false;
-        }
-        sk_bzero(dst.writable_addr(), dst.getSafeSize());
 
-        // rasterize path
-        SkPaint paint;
-        paint.setStyle(SkPaint::kFill_Style);
-        paint.setAntiAlias(antiAlias);
-
-        SkDraw draw;
-        sk_bzero(&draw, sizeof(draw));
-
-        SkRasterClip rasterClip;
-        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);
-        width = devPathBounds.width();
-        height = devPathBounds.height();
+        // setup signed distance field storage
+        SkIRect sdfPathBounds = devPathBounds.makeOutset(SK_DistanceFieldPad, SK_DistanceFieldPad);
+        width = sdfPathBounds.width();
+        height = sdfPathBounds.height();
         // TODO We should really generate this directly into the plot somehow
         SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char));
 
-        // Generate signed distance field
-        SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
-                                           (const unsigned char*)dst.addr(),
-                                           dst.width(), dst.height(), dst.rowBytes());
+        bool success = false;
+        if (SkPath::kEvenOdd_FillType == path.getFillType()) {
+            // Generate signed distance field directly from SkPath
+            // TODO: Support non-zero fill type (SkPath::kWinding_FillType)

[bsalomon, 2016/02/02 18:03:48]

Have you tried using using Simplify from SkPathOps.h for winding fill?

[Joel.Liang, 2016/02/04 12:12:05]

Wow, now we can pass all test cases in DM by using the new algorithm after
simplify the paths.

+            success = GrGenerateDistanceFieldFromPath((unsigned char*)dfStorage.get(),
+                                            path, drawMatrix,
+                                            width, height, width * sizeof(unsigned char));
+        }
+        if (!success) {
+            // setup bitmap backing
+            SkAutoPixmapStorage dst;
+            if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(),
+                                                  devPathBounds.height()))) {
+                return false;
+            }
+            sk_bzero(dst.writable_addr(), dst.getSafeSize());
+
+            // rasterize path
+            SkPaint paint;
+            paint.setStyle(SkPaint::kFill_Style);
+            paint.setAntiAlias(antiAlias);
+
+            SkDraw draw;
+            sk_bzero(&draw, sizeof(draw));
+
+            SkRasterClip rasterClip;
+            rasterClip.setRect(devPathBounds);
+            draw.fRC = &rasterClip;
+            draw.fClip = &rasterClip.bwRgn();
+            draw.fMatrix = &drawMatrix;
+            draw.fDst = dst;
+
+            draw.drawPathCoverage(path, paint);
+
+            // Generate signed distance field
+            SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
+                                               (const unsigned char*)dst.addr(),
+                                               dst.width(), dst.height(), dst.rowBytes());
+        }
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
-        bool success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(),
+        success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(),
                                          &atlasLocation);
         if (!success) {
             this->flush(target, flushInfo);
             target->initDraw(dfProcessor, pipeline);
 
             SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height,
                                                      dfStorage.get(), &atlasLocation);
             SkASSERT(success);
 
         }
@@ skipping 147 matching lines @@
         geometry.fPath = *args.fPath;
     } else {
         args.fStroke->applyToPath(&geometry.fPath, *args.fPath);
     }
     geometry.fColor = args.fColor;
     geometry.fAntiAlias = args.fAntiAlias;
     // 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.
     geometry.fGenID = args.fPath->getGenerationID();
- 
+
     SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry,
                                                                      *args.fViewMatrix, fAtlas,
                                                                      &fPathCache, &fPathList));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 64 matching lines @@
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif