added stroking support to GrAALinearizingConvexPathRenderer

src/gpu/GrAALinearizingConvexPathRenderer.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 "GrAALinearizingConvexPathRenderer.h"
 
 #include "GrAAConvexTessellator.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBatchTest.h"
 #include "GrContext.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrGeometryProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrPathUtils.h"
 #include "GrProcessor.h"
 #include "GrPipelineBuilder.h"
 #include "GrStrokeInfo.h"
 #include "SkGeometry.h"
 #include "SkString.h"
 #include "SkTraceEvent.h"
+#include "SkPathPriv.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
-#define DEFAULT_BUFFER_SIZE 100
+static const int DEFAULT_BUFFER_SIZE = 100;
+
+// The thicker the stroke, the harder it is to produce high-quality results using tessellation. For
+// the time being, we simply drop back to software rendering above this stroke width.
+static const SkScalar kMaxStrokeWidth = 20.0;
 
 GrAALinearizingConvexPathRenderer::GrAALinearizingConvexPathRenderer() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAALinearizingConvexPathRenderer::canDrawPath(const GrDrawTarget* target,
                                                     const GrPipelineBuilder*,
                                                     const SkMatrix& viewMatrix,
                                                     const SkPath& path,
                                                     const GrStrokeInfo& stroke,
                                                     bool antiAlias) const {
-    return (antiAlias && stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
+    if (!antiAlias) {
+        return false;
+    }
+    if (path.isInverseFillType()) {
+        return false;
+    }
+    if (!path.isConvex()) {
+        return false;
+    }
+    if (stroke.getStyle() == SkStrokeRec::kStroke_Style) {
+        return viewMatrix.isSimilarity() && stroke.getWidth() >= 1.0f && 
+                stroke.getWidth() <= kMaxStrokeWidth && !stroke.isDashed() && 
+                SkPathPriv::LastVerbIsClose(path) && stroke.getJoin() != SkPaint::Join::kRound_Join;
+    }
+    return stroke.getStyle() == SkStrokeRec::kFill_Style;
 }
 
 // extract the result vertices and indices from the GrAAConvexTessellator
 static void extract_verts(const GrAAConvexTessellator& tess,
                           void* vertices,
                           size_t vertexStride,
                           GrColor color,
                           uint16_t firstIndex,
                           uint16_t* idxs,
                           bool tweakAlphaForCoverage) {
     intptr_t verts = reinterpret_cast<intptr_t>(vertices);
 
     for (int i = 0; i < tess.numPts(); ++i) {
         *((SkPoint*)((intptr_t)verts + i * vertexStride)) = tess.point(i);
     }
 
     // Make 'verts' point to the colors
     verts += sizeof(SkPoint);
     for (int i = 0; i < tess.numPts(); ++i) {
-        SkASSERT(tess.depth(i) >= -0.5f && tess.depth(i) <= 0.5f);
         if (tweakAlphaForCoverage) {
-            SkASSERT(SkScalarRoundToInt(255.0f * (tess.depth(i) + 0.5f)) <= 255);
-            unsigned scale = SkScalarRoundToInt(255.0f * (tess.depth(i) + 0.5f));
+            SkASSERT(SkScalarRoundToInt(255.0f * tess.coverage(i)) <= 255);
+            unsigned scale = SkScalarRoundToInt(255.0f * tess.coverage(i));
             GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
             *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 
-                                                                    tess.depth(i) + 0.5f;
+                    tess.coverage(i);
         }
     }
 
     for (int i = 0; i < tess.numIndices(); ++i) {
         idxs[i] = tess.index(i) + firstIndex;
     }
 }
 
 static const GrGeometryProcessor* create_fill_gp(bool tweakAlphaForCoverage,
                                                  const SkMatrix& localMatrix,
                                                  bool usesLocalCoords,
                                                  bool coverageIgnored) {
     uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType;
     if (!tweakAlphaForCoverage) {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
     }
 
     return GrDefaultGeoProcFactory::Create(flags, GrColor_WHITE, usesLocalCoords, coverageIgnored,
                                            SkMatrix::I(), localMatrix);
 }
 
 class AAFlatteningConvexPathBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkPath fPath;
+        SkScalar fStrokeWidth;
+        SkPaint::Join fJoin;
+        SkScalar fMiterLimit;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(AAFlatteningConvexPathBatch, (geometry));
     }
 
     const char* name() const override { return "AAConvexBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 41 matching lines @@
         uint16_t* idxs = batchTarget->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
         if (!idxs) {
             SkDebugf("Could not allocate indices\n");
             return;
         }
         memcpy(idxs, indices, indexCount * sizeof(uint16_t));
         info.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex, 
                 firstIndex, vertexCount, indexCount);
         batchTarget->draw(info);
     }
-
+    
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         // Setup GrGeometryProcessor
         SkAutoTUnref<const GrGeometryProcessor> gp(
                                                 create_fill_gp(canTweakAlphaForCoverage, invert,
                                                                this->usesLocalCoords(),
                                                                this->coverageIgnored()));
 
         batchTarget->initDraw(gp, pipeline);
 
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(canTweakAlphaForCoverage ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
 
-        GrAAConvexTessellator tess;
-
         int instanceCount = fGeoData.count();
 
         int vertexCount = 0;
         int indexCount = 0;
         int maxVertices = DEFAULT_BUFFER_SIZE;
         int maxIndices = DEFAULT_BUFFER_SIZE;
         uint8_t* vertices = (uint8_t*) malloc(maxVertices * vertexStride);
         uint16_t* indices = (uint16_t*) malloc(maxIndices * sizeof(uint16_t));
         for (int i = 0; i < instanceCount; i++) {
-            tess.rewind();
-
             Geometry& args = fGeoData[i];
+            GrAAConvexTessellator tess(args.fStrokeWidth, args.fJoin, args.fMiterLimit);
 
             if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
                 continue;
             }
 
             int currentIndices = tess.numIndices();
             SkASSERT(currentIndices <= UINT16_MAX);
             if (indexCount + currentIndices > UINT16_MAX) {
                 // if we added the current instance, we would overflow the indices we can store in a 
                 // uint16_t. Draw what we've got so far and reset.
@@ skipping 71 matching lines @@
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 bool GrAALinearizingConvexPathRenderer::onDrawPath(GrDrawTarget* target,
                                                    GrPipelineBuilder* pipelineBuilder,
                                                    GrColor color,
                                                    const SkMatrix& vm,
                                                    const SkPath& path,
-                                                   const GrStrokeInfo&,
+                                                   const GrStrokeInfo& stroke,
                                                    bool antiAlias) {
     if (path.isEmpty()) {
         return true;
     }
     AAFlatteningConvexPathBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fViewMatrix = vm;
     geometry.fPath = path;
+    geometry.fStrokeWidth = stroke.isFillStyle() ? -1.0f : stroke.getWidth();
+    geometry.fJoin = stroke.isFillStyle() ? SkPaint::Join::kMiter_Join : stroke.getJoin();
+    geometry.fMiterLimit = stroke.getMiter();
 
     SkAutoTUnref<GrBatch> batch(AAFlatteningConvexPathBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(AAFlatteningConvexPathBatch) {
     AAFlatteningConvexPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return AAFlatteningConvexPathBatch::Create(geometry);
 }
 
 #endif