Chop tessellated strokes in the vertex shader

The stroke tessellator can't handle inflections and can't handle
rotations greater than 180 degrees. Before this CL we had to use the CPU
to chop curves at their inflections and midtangents in order to meet
these constraints. This CL adds a vertex shader to the tessellation
pipeline that handles all the chopping logic on the GPU.

Bug: skia:10419
Change-Id: I2d3279076bafa415395e014772a305e616fcff71
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/315797
Commit-Queue: Chris Dalton <[email protected]>
Reviewed-by: Brian Salomon <[email protected]>

Author: csmartdalton86

src/gpu/tessellate/GrStrokePatchBuilder.cpp

@@ -17,41 +17,43 @@
 #include "src/gpu/tessellate/GrVectorXform.h"
 #include "src/gpu/tessellate/GrWangsFormula.h"
 
-constexpr static float kStandardCubicType = GrStrokeTessellateShader::kStandardCubicType;
-constexpr static float kDoubleSidedRoundJoinType = -GrStrokeTessellateShader::kRoundJoinType;
+using Patch = GrStrokeTessellateShader::Patch;
+
+constexpr static float kDoubleSidedRoundJoinType = -Patch::kRoundJoinType;
 
 static SkPoint lerp(const SkPoint& a, const SkPoint& b, float T) {
     SkASSERT(1 != T);  // The below does not guarantee lerp(a, b, 1) === b.
     return (b - a) * T + a;
 }
 
-void GrStrokePatchBuilder::allocVertexChunk(int minVertexAllocCount) {
-    VertexChunk* chunk = &fVertexChunkArray->push_back();
-    fCurrChunkVertexData = (SkPoint*)fTarget->makeVertexSpaceAtLeast(
-            sizeof(SkPoint), minVertexAllocCount, minVertexAllocCount, &chunk->fVertexBuffer,
-            &chunk->fBaseVertex, &fCurrChunkVertexCapacity);
-    fCurrChunkMinVertexAllocCount = minVertexAllocCount;
+void GrStrokePatchBuilder::allocPatchChunkAtLeast(int minPatchAllocCount) {
+    PatchChunk* chunk = &fPatchChunkArray->push_back();
+    fCurrChunkPatchData = (Patch*)fTarget->makeVertexSpaceAtLeast(sizeof(Patch), minPatchAllocCount,
+                                                                  minPatchAllocCount,
+                                                                  &chunk->fPatchBuffer,
+                                                                  &chunk->fBasePatch,
+                                                                  &fCurrChunkPatchCapacity);
+    fCurrChunkMinPatchAllocCount = minPatchAllocCount;
 }
 
-SkPoint* GrStrokePatchBuilder::reservePatch() {
-    constexpr static int kNumVerticesPerPatch = GrStrokeTessellateShader::kNumVerticesPerPatch;
-    if (fVertexChunkArray->back().fVertexCount + kNumVerticesPerPatch > fCurrChunkVertexCapacity) {
+Patch* GrStrokePatchBuilder::reservePatch() {
+    if (fPatchChunkArray->back().fPatchCount >= fCurrChunkPatchCapacity) {
         // The current chunk is full. Time to allocate a new one. (And no need to put back vertices;
         // the buffer is full.)
-        this->allocVertexChunk(fCurrChunkMinVertexAllocCount * 2);
+        this->allocPatchChunkAtLeast(fCurrChunkMinPatchAllocCount * 2);
     }
-    if (!fCurrChunkVertexData) {
+    if (!fCurrChunkPatchData) {
         SkDebugf("WARNING: Failed to allocate vertex buffer for tessellated stroke.");
         return nullptr;
     }
-    SkASSERT(fVertexChunkArray->back().fVertexCount + kNumVerticesPerPatch <=
-             fCurrChunkVertexCapacity);
-    SkPoint* patch = fCurrChunkVertexData + fVertexChunkArray->back().fVertexCount;
-    fVertexChunkArray->back().fVertexCount += kNumVerticesPerPatch;
+    SkASSERT(fPatchChunkArray->back().fPatchCount <= fCurrChunkPatchCapacity);
+    Patch* patch = fCurrChunkPatchData + fPatchChunkArray->back().fPatchCount;
+    ++fPatchChunkArray->back().fPatchCount;
     return patch;
 }
 
-void GrStrokePatchBuilder::writeCubicSegment(float prevJoinType, const SkPoint pts[4]) {
+void GrStrokePatchBuilder::writeCubicSegment(float prevJoinType, const SkPoint pts[4],
+                                             float cubicType) {
     SkPoint c1 = (pts[1] == pts[0]) ? pts[2] : pts[1];
     SkPoint c2 = (pts[2] == pts[3]) ? pts[1] : pts[2];
 
@@ -62,9 +64,11 @@ void GrStrokePatchBuilder::writeCubicSegment(float prevJoinType, const SkPoint p
         fHasPreviousSegment = true;
     }
 
-    if (SkPoint* patch = this->reservePatch()) {
-        memcpy(patch, pts, sizeof(SkPoint) * 4);
-        patch[4].set(kStandardCubicType, fCurrStrokeRadius);
+    SkASSERT(cubicType == Patch::kStandardCubicType || cubicType == Patch::kFlatLineType);
+    if (Patch* patch = this->reservePatch()) {
+        memcpy(patch->fPts.data(), pts, sizeof(patch->fPts));
+        patch->fPatchType = cubicType;
+        patch->fStrokeRadius = fCurrStrokeRadius;
     }
 
     fLastControlPoint = c2;
@@ -73,12 +77,12 @@ void GrStrokePatchBuilder::writeCubicSegment(float prevJoinType, const SkPoint p
 
 void GrStrokePatchBuilder::writeJoin(float joinType, const SkPoint& prevControlPoint,
                                      const SkPoint& anchorPoint, const SkPoint& nextControlPoint) {
-    if (SkPoint* joinPatch = this->reservePatch()) {
-        joinPatch[0] = prevControlPoint;
-        joinPatch[1] = anchorPoint;
-        joinPatch[2] = anchorPoint;
-        joinPatch[3] = nextControlPoint;
-        joinPatch[4].set(joinType, fCurrStrokeRadius);
+    SkASSERT(joinType == Patch::kRoundJoinType || joinType == Patch::kMiterJoinType ||
+             joinType == Patch::kRoundJoinType || joinType == kDoubleSidedRoundJoinType);
+    if (Patch* joinPatch = this->reservePatch()) {
+        joinPatch->fPts = {{prevControlPoint, anchorPoint, anchorPoint, nextControlPoint}};
+        joinPatch->fPatchType = joinType;
+        joinPatch->fStrokeRadius = fCurrStrokeRadius;
     }
 }
 
@@ -89,12 +93,10 @@ void GrStrokePatchBuilder::writeSquareCap(const SkPoint& endPoint, const SkPoint
     // Add a join to guarantee we get water tight seaming. Make the join type negative so it's
     // double sided.
     this->writeJoin(-fCurrStrokeJoinType, controlPoint, endPoint, capPoint);
-    if (SkPoint* capPatch = this->reservePatch()) {
-        capPatch[0] = endPoint;
-        capPatch[1] = endPoint;
-        capPatch[2] = capPoint;
-        capPatch[3] = capPoint;
-        capPatch[4].set(kStandardCubicType, fCurrStrokeRadius);
+    if (Patch* capPatch = this->reservePatch()) {
+        capPatch->fPts = {{endPoint, endPoint, capPoint, capPoint}};
+        capPatch->fPatchType = Patch::kFlatLineType;
+        capPatch->fStrokeRadius = fCurrStrokeRadius;
     }
 }
 
@@ -113,10 +115,10 @@ void GrStrokePatchBuilder::writeCaps(SkPaint::Cap capType) {
             break;
         case SkPaint::kRound_Cap:
             // A round cap is the same thing as a 180-degree round join.
-            this->writeJoin(GrStrokeTessellateShader::kRoundJoinType, fCurrContourFirstControlPoint,
+            this->writeJoin(Patch::kRoundJoinType, fCurrContourFirstControlPoint,
                             fCurrContourStartPoint, fCurrContourFirstControlPoint);
-            this->writeJoin(GrStrokeTessellateShader::kRoundJoinType, fLastControlPoint,
-                            fCurrentPoint, fLastControlPoint);
+            this->writeJoin(Patch::kRoundJoinType, fLastControlPoint, fCurrentPoint,
+                            fLastControlPoint);
             break;
         case SkPaint::kSquare_Cap:
             this->writeSquareCap(fCurrContourStartPoint, fCurrContourFirstControlPoint);
@@ -128,11 +130,11 @@ void GrStrokePatchBuilder::writeCaps(SkPaint::Cap capType) {
 static float join_type_from_join(SkPaint::Join join) {
     switch (join) {
         case SkPaint::kBevel_Join:
-            return GrStrokeTessellateShader::kBevelJoinType;
+            return GrStrokeTessellateShader::Patch::kBevelJoinType;
         case SkPaint::kMiter_Join:
-            return GrStrokeTessellateShader::kMiterJoinType;
+            return GrStrokeTessellateShader::Patch::kMiterJoinType;
         case SkPaint::kRound_Join:
-            return GrStrokeTessellateShader::kRoundJoinType;
+            return GrStrokeTessellateShader::Patch::kRoundJoinType;
     }
     SkUNREACHABLE;
 }
@@ -210,7 +212,7 @@ void GrStrokePatchBuilder::lineTo(float prevJoinType, const SkPoint& p0, const S
     }
 
     SkPoint cubic[4] = {p0, p0, p1, p1};
-    this->writeCubicSegment(prevJoinType, cubic);
+    this->writeCubicSegment(prevJoinType, cubic, Patch::kFlatLineType);
 }
 
 void GrStrokePatchBuilder::quadraticTo(float prevJoinType, const SkPoint p[3], int maxDepth) {
@@ -257,44 +259,11 @@ void GrStrokePatchBuilder::quadraticTo(float prevJoinType, const SkPoint p[3], i
     }
 
     SkPoint cubic[4] = {p[0], lerp(p[0], p[1], 2/3.f), lerp(p[1], p[2], 1/3.f), p[2]};
-    this->writeCubicSegment(prevJoinType, cubic);
-}
-
-void GrStrokePatchBuilder::cubicTo(float prevJoinType, const SkPoint inputPts[4]) {
-    const SkPoint* p = inputPts;
-    int numCubics = 1;
-    SkPoint chopped[10];
-    double tt[2], ss[2];
-    if (SkClassifyCubic(p, tt, ss) == SkCubicType::kSerpentine) {
-        // TEMPORARY: Don't allow cubics to have inflection points.
-        // TODO: This will soon be moved into the GPU tessellation pipeline and handled more
-        // elegantly.
-        float t[2] = {(float)(tt[0]/ss[0]), (float)(tt[1]/ss[1])};
-        const float* begin = (t[0] > 0 && t[0] < 1) ? t : t+1;
-        const float* end = (t[1] > 0 && t[1] > t[0] && t[1] < 1) ? t+2 : t+1;
-        numCubics = (end - begin) + 1;
-        if (numCubics > 1) {
-            SkChopCubicAt(p, chopped, begin, end - begin);
-            p = chopped;
-        }
-    } else if (SkMeasureNonInflectCubicRotation(p) > SK_ScalarPI*15/16) {
-        // TEMPORARY: Don't allow cubics to turn more than 180 degrees. We chop them when they get
-        // close, just to be sure.
-        // TODO: This will soon be moved into the GPU tessellation pipeline and handled more
-        // elegantly.
-        SkChopCubicAtMidTangent(p, chopped);
-        p = chopped;
-        numCubics = 2;
-    }
-    for (int i = 0; i < numCubics; ++i) {
-        this->nonInflectCubicTo(prevJoinType, p + i*3);
-        // Use kDoubleSidedRoundJoinType in case we happened to chop at an exact cusp or turnaround
-        // point of a flat cubic, in which case we would lose 180 degrees of rotation.
-        prevJoinType = kDoubleSidedRoundJoinType;
-    }
+    this->writeCubicSegment(prevJoinType, cubic, Patch::kStandardCubicType);
 }
 
-void GrStrokePatchBuilder::nonInflectCubicTo(float prevJoinType, const SkPoint p[4], int maxDepth) {
+void GrStrokePatchBuilder::cubicTo(float prevJoinType, const SkPoint p[4], int maxDepth,
+                                   bool mightInflect) {
     // The stroker relies on p1 and p2 to find tangents at the endpoints. (We have to treat the
     // endpoint tangents carefully in order to get water tight seams with the join segments.) If p0
     // and p1 are both colocated on an endpoint then we need to draw this cubic as a line instead.
@@ -303,46 +272,62 @@ void GrStrokePatchBuilder::nonInflectCubicTo(float prevJoinType, const SkPoint p
         return;
     }
 
-    // Ensure our hardware supports enough tessellation segments to render the curve. The first
-    // branch assumes a worst-case rotation of 360 degrees and checks if even then we have enough.
-    // In practice it is rare to take even the first branch.
-    //
-    // NOTE: We could technically assume a worst-case rotation of 180 because cubicTo() chops at
-    // midtangents and inflections. However, this is only temporary so we leave it at 360 where it
-    // will arrive at in the future.
+    // Early-out if by conservative estimate we can ensure our hardware supports enough tessellation
+    // segments to render the curve. In practice we almost always take this branch.
     float numParametricSegments = GrWangsFormula::cubic(fLinearizationIntolerance, p);
-    if (numParametricSegments > fMaxParametricSegments360 && maxDepth != 0) {
-        // We still might have enough tessellation segments to render the curve. Check again with
-        // the actual rotation.
-        float numRadialSegments = SkMeasureNonInflectCubicRotation(p) * fNumRadialSegmentsPerRad;
-        numRadialSegments = std::max(std::ceil(numRadialSegments), 1.f);
-        numParametricSegments = std::max(std::ceil(numParametricSegments), 1.f);
-        if (numParametricSegments + numRadialSegments - 1 > fMaxTessellationSegments) {
-            // The hardware doesn't support enough segments for this curve. Chop and recurse.
-            if (maxDepth < 0) {
-                // Decide on an extremely conservative upper bound for when to quit chopping. This
-                // is solely to protect us from infinite recursion in instances where FP error
-                // prevents us from chopping at the correct midtangent.
-                maxDepth = sk_float_nextlog2(numParametricSegments) +
-                           sk_float_nextlog2(numRadialSegments) + 1;
-                SkASSERT(maxDepth >= 1);
-            }
-            SkPoint chopped[7];
-            if (numParametricSegments >= numRadialSegments) {
-                SkChopCubicAtHalf(p, chopped);
-            } else {
-                SkChopCubicAtMidTangent(p, chopped);
+    if (numParametricSegments <= fMaxParametricSegments360 || maxDepth == 0) {
+        this->writeCubicSegment(prevJoinType, p, Patch::kStandardCubicType);
+        return;
+    }
+
+    // Ensure the curve does not inflect before we attempt to measure its rotation.
+    SkPoint chopped[10];
+    if (mightInflect) {
+        float inflectT[2];
+        if (int n = SkFindCubicInflections(p, inflectT)) {
+            SkChopCubicAt(p, chopped, inflectT, n);
+            for (int i = 0; i <= n; ++i) {
+                this->cubicTo(prevJoinType, chopped + i*3, maxDepth, false);
+                // Switch to kDoubleSidedRoundJoinType in case we happened to chop at an exact cusp
+                // or turnaround point of a flat cubic, in which case we would lose 180 degrees of
+                // rotation.
+                prevJoinType = kDoubleSidedRoundJoinType;
             }
-            this->nonInflectCubicTo(prevJoinType, chopped, maxDepth - 1);
-            // Use kDoubleSidedRoundJoinType in case we happened to chop at an exact cusp or
-            // turnaround point of a flat cubic, in which case we would lose 180 degrees of
-            // rotation.
-            this->nonInflectCubicTo(kDoubleSidedRoundJoinType, chopped + 3, maxDepth - 1);
             return;
         }
     }
 
-    this->writeCubicSegment(prevJoinType, p);
+    // We still might have enough tessellation segments to render the curve. Check again with
+    // its actual rotation.
+    float numRadialSegments = SkMeasureNonInflectCubicRotation(p) * fNumRadialSegmentsPerRad;
+    numRadialSegments = std::max(std::ceil(numRadialSegments), 1.f);
+    numParametricSegments = std::max(std::ceil(numParametricSegments), 1.f);
+    if (numParametricSegments + numRadialSegments - 1 <= fMaxTessellationSegments) {
+        this->writeCubicSegment(prevJoinType, p, Patch::kStandardCubicType);
+        return;
+    }
+
+    // The hardware doesn't support enough segments to tessellate this curve. Chop and recurse.
+    if (numParametricSegments >= numRadialSegments) {
+        SkChopCubicAtHalf(p, chopped);
+    } else {
+        SkChopCubicAtMidTangent(p, chopped);
+    }
+
+    if (maxDepth < 0) {
+        // Decide on an extremely conservative upper bound for when to quit chopping. This
+        // is solely to protect us from infinite recursion in instances where FP error
+        // prevents us from chopping at the correct midtangent.
+        maxDepth = sk_float_nextlog2(numParametricSegments) +
+                   sk_float_nextlog2(numRadialSegments) + 1;
+        SkASSERT(maxDepth >= 1);
+    }
+
+    this->cubicTo(prevJoinType, chopped, maxDepth - 1, false);
+    // Use kDoubleSidedRoundJoinType in case we happened to chop at an exact cusp or
+    // turnaround point of a flat cubic, in which case we would lose 180 degrees of
+    // rotation.
+    this->cubicTo(kDoubleSidedRoundJoinType, chopped + 3, maxDepth - 1, false);
 }
 
 void GrStrokePatchBuilder::close(SkPaint::Cap capType) {