CCPR: Merge triangle hull and edge shaders

Bug: skia:
Change-Id: I728454220781fa947fb6562c85c5c1ec54a83754
Reviewed-on: https://skia-review.googlesource.com/86420
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>

7 files changed, 63 insertions, 73 deletions

diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
index 68166c02b6..3a456fda00 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
@@ -87,10 +87,8 @@ GrGLSLPrimitiveProcessor* GrCCPRCoverageProcessor::createGLSLInstance(const GrSh
     std::unique_ptr<Shader> shader;
     switch (fRenderPass) {
         case RenderPass::kTriangleHulls:
-            shader = skstd::make_unique<GrCCPRTriangleHullShader>();
-            break;
         case RenderPass::kTriangleEdges:
-            shader = skstd::make_unique<GrCCPRTriangleEdgeShader>();
+            shader = skstd::make_unique<GrCCPRTriangleShader>();
             break;
         case RenderPass::kTriangleCorners:
             shader = skstd::make_unique<GrCCPRTriangleCornerShader>();
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.h b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
index 6bc3fadf29..7210d3975e 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.h
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
@@ -57,9 +57,9 @@ public:
     enum class RenderPass {
         // For a Hull, the Impl generates a "conservative raster hull" around the input points. This
         // is the geometry that causes a pixel to be rasterized if it is touched anywhere by the
-        // input polygon. The initial coverage values sent to the Shader at each vertex are +1 all
-        // around. Logically, the conservative raster hull is equivalent to the convex hull of pixel
-        // size boxes centered on each input point.
+        // input polygon. Initial coverage values sent to the Shader at each vertex will be null.
+        // Logically, the conservative raster hull is equivalent to the convex hull of pixel size
+        // boxes centered on each input point.
         kTriangleHulls,
         kQuadraticHulls,
         kCubicHulls,
@@ -74,8 +74,7 @@ public:
 
         // For Corners, the Impl Generates the conservative rasters of corner points (i.e.
         // pixel-size boxes). It generates 3 corner boxes for triangles and 2 for curves. The Shader
-        // specifies which corners. The initial coverage values sent to the Shader at each pixel are
-        // +1 all around.
+        // specifies which corners. Initial coverage values sent to the Shader will be null.
         kTriangleCorners,
         kQuadraticCorners,
         kCubicCorners
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
index a832f625c2..5006ff5a4b 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
@@ -66,7 +66,10 @@ protected:
         SkString emitVertexFn;
         SkSTArray<2, GrShaderVar> emitArgs;
         const char* position = emitArgs.emplace_back("position", kFloat2_GrSLType).c_str();
-        const char* coverage = emitArgs.emplace_back("coverage", kHalf_GrSLType).c_str();
+        const char* coverage = nullptr;
+        if (RenderPass::kTriangleEdges == proc.fRenderPass) {
+            coverage = emitArgs.emplace_back("coverage", kHalf_GrSLType).c_str();
+        }
         g->emitFunction(kVoid_GrSLType, "emitVertex", emitArgs.count(), emitArgs.begin(), [&]() {
             SkString fnBody;
             fShader->emitVaryings(varyingHandler, &fnBody, position, coverage, wind.c_str());
@@ -139,16 +142,16 @@ public:
         g->codeAppend ("if (all(left_right_notequal)) {");
                            // The top corner will have three conservative raster vertices. Emit the
                            // middle one first to the triangle strip.
-        g->codeAppendf(    "%s(top + float2(-leftbloat.y, leftbloat.x), 1);", emitVertexFn);
+        g->codeAppendf(    "%s(top + float2(-leftbloat.y, leftbloat.x));", emitVertexFn);
         g->codeAppend ("}");
         g->codeAppend ("if (any(left_right_notequal)) {");
                            // Second conservative raster vertex for the top corner.
-        g->codeAppendf(    "%s(top + rightbloat, 1);", emitVertexFn);
+        g->codeAppendf(    "%s(top + rightbloat);", emitVertexFn);
         g->codeAppend ("}");
 
         // Main interior body of the triangle.
-        g->codeAppendf("%s(top + leftbloat, 1);", emitVertexFn);
-        g->codeAppendf("%s(right + rightbloat, 1);", emitVertexFn);
+        g->codeAppendf("%s(top + leftbloat);", emitVertexFn);
+        g->codeAppendf("%s(right + rightbloat);", emitVertexFn);
 
         // Here the two invocations diverge. We can't symmetrically divide three triangle points
         // between two invocations, so each does the following:
@@ -157,11 +160,11 @@ public:
         // sk_InvocationID=1: Remaining two conservative raster vertices for the third corner.
         g->codeAppendf("bool2 right_down_notequal = notEqual(rightbloat, downbloat);");
         g->codeAppend ("if (any(right_down_notequal) || 0 == sk_InvocationID) {");
-        g->codeAppendf(    "%s(sk_InvocationID == 0 ? left + leftbloat : right + downbloat, 1);",
+        g->codeAppendf(    "%s(sk_InvocationID == 0 ? left + leftbloat : right + downbloat);",
                            emitVertexFn);
         g->codeAppend ("}");
         g->codeAppend ("if (all(right_down_notequal) && 0 != sk_InvocationID) {");
-        g->codeAppendf(    "%s(right + float2(-rightbloat.y, rightbloat.x), 1);", emitVertexFn);
+        g->codeAppendf(    "%s(right + float2(-rightbloat.y, rightbloat.x));", emitVertexFn);
         g->codeAppend ("}");
 
         g->configure(InputType::kLines, OutputType::kTriangleStrip, 6, 2);
@@ -214,27 +217,25 @@ public:
         g->codeAppend ("if (all(left_up_notequal)) {");
                            // The top-left corner will have three conservative raster vertices.
                            // Emit the middle one first to the triangle strip.
-        g->codeAppendf(    "%s(topleft + float2(-leftbloat.y, leftbloat.x), 1);",
-                           emitVertexFn);
+        g->codeAppendf(    "%s(topleft + float2(-leftbloat.y, leftbloat.x));", emitVertexFn);
         g->codeAppend ("}");
         g->codeAppend ("if (any(left_up_notequal)) {");
                            // Second conservative raster vertex for the top-left corner.
-        g->codeAppendf(    "%s(topleft + leftbloat, 1);", emitVertexFn);
+        g->codeAppendf(    "%s(topleft + leftbloat);", emitVertexFn);
         g->codeAppend ("}");
 
         // Main interior body of this invocation's half of the hull.
-        g->codeAppendf("%s(topleft + upbloat, 1);", emitVertexFn);
-        g->codeAppendf("%s(bottomleft + leftbloat, 1);", emitVertexFn);
-        g->codeAppendf("%s(topright + upbloat, 1);", emitVertexFn);
+        g->codeAppendf("%s(topleft + upbloat);", emitVertexFn);
+        g->codeAppendf("%s(bottomleft + leftbloat);", emitVertexFn);
+        g->codeAppendf("%s(topright + upbloat);", emitVertexFn);
 
         // Remaining two conservative raster vertices for the top-right corner.
         g->codeAppendf("bool2 up_right_notequal = notEqual(upbloat, rightbloat);");
         g->codeAppend ("if (any(up_right_notequal)) {");
-        g->codeAppendf(    "%s(topright + rightbloat, 1);", emitVertexFn);
+        g->codeAppendf(    "%s(topright + rightbloat);", emitVertexFn);
         g->codeAppend ("}");
         g->codeAppend ("if (all(up_right_notequal)) {");
-        g->codeAppendf(    "%s(topright + float2(-upbloat.y, upbloat.x), 1);",
-                           emitVertexFn);
+        g->codeAppendf(    "%s(topright + float2(-upbloat.y, upbloat.x));", emitVertexFn);
         g->codeAppend ("}");
 
         g->configure(InputType::kLines, OutputType::kTriangleStrip, 7, 2);
@@ -306,10 +307,10 @@ public:
         const char* corner = vars.fCornerVars.fPoint;
         SkASSERT(corner);
 
-        g->codeAppendf("%s(%s + float2(-bloat, -bloat), 1);", emitVertexFn, corner);
-        g->codeAppendf("%s(%s + float2(-bloat, +bloat), 1);", emitVertexFn, corner);
-        g->codeAppendf("%s(%s + float2(+bloat, -bloat), 1);", emitVertexFn, corner);
-        g->codeAppendf("%s(%s + float2(+bloat, +bloat), 1);", emitVertexFn, corner);
+        g->codeAppendf("%s(%s + float2(-bloat, -bloat));", emitVertexFn, corner);
+        g->codeAppendf("%s(%s + float2(-bloat, +bloat));", emitVertexFn, corner);
+        g->codeAppendf("%s(%s + float2(+bloat, -bloat));", emitVertexFn, corner);
+        g->codeAppendf("%s(%s + float2(+bloat, +bloat));", emitVertexFn, corner);
 
         g->configure(InputType::kLines, OutputType::kTriangleStrip, 4, fNumCorners);
     }
diff --git a/src/gpu/ccpr/GrCCPRCubicShader.cpp b/src/gpu/ccpr/GrCCPRCubicShader.cpp
index 0d34d3748a..c9e546a74b 100644
--- a/src/gpu/ccpr/GrCCPRCubicShader.cpp
+++ b/src/gpu/ccpr/GrCCPRCubicShader.cpp
@@ -10,6 +10,8 @@
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLVertexGeoBuilder.h"
 
+using Shader = GrCCPRCoverageProcessor::Shader;
+
 void GrCCPRCubicShader::emitSetupCode(GrGLSLVertexGeoBuilder* s, const char* pts,
                                       const char* repetitionID, const char* wind,
                                       GeometryVars* vars) const {
@@ -73,10 +75,11 @@ void GrCCPRCubicShader::emitSetupCode(GrGLSLVertexGeoBuilder* s, const char* pts
     this->onEmitSetupCode(s, pts, repetitionID, vars);
 }
 
-GrCCPRCubicShader::WindHandling
-GrCCPRCubicShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code,
-                                  const char* position, const char* /*coverage*/,
-                                  const char* /*wind*/) {
+Shader::WindHandling GrCCPRCubicShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
+                                                       SkString* code, const char* position,
+                                                       const char* coverage, const char* /*wind*/) {
+    SkASSERT(!coverage);
+
     varyingHandler->addVarying("klmd", &fKLMD);
     code->appendf("float3 klm = float3(%s, 1) * %s;", position, fKLMMatrix.c_str());
     code->appendf("float d = dot(float3(%s, 1), %s);", position, fEdgeDistanceEquation.c_str());
diff --git a/src/gpu/ccpr/GrCCPRQuadraticShader.cpp b/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
index bccba21d0c..308e3ff927 100644
--- a/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
+++ b/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
@@ -10,6 +10,8 @@
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLVertexGeoBuilder.h"
 
+using Shader = GrCCPRCoverageProcessor::Shader;
+
 void GrCCPRQuadraticShader::emitSetupCode(GrGLSLVertexGeoBuilder* s, const char* pts,
                                           const char* repetitionID, const char* wind,
                                           GeometryVars* vars) const {
@@ -30,10 +32,12 @@ void GrCCPRQuadraticShader::emitSetupCode(GrGLSLVertexGeoBuilder* s, const char*
     this->onEmitSetupCode(s, pts, repetitionID, vars);
 }
 
-GrCCPRQuadraticShader::WindHandling
-GrCCPRQuadraticShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code,
-                                      const char* position, const char* /*coverage*/,
-                                      const char* /*wind*/) {
+Shader::WindHandling GrCCPRQuadraticShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
+                                                           SkString* code, const char* position,
+                                                           const char* coverage,
+                                                           const char* /*wind*/) {
+    SkASSERT(!coverage);
+
     varyingHandler->addVarying("xyd", &fXYD);
     code->appendf("%s.xy = (%s * float3(%s, 1)).xy;",
                   fXYD.gsOut(), fCanonicalMatrix.c_str(), position);
diff --git a/src/gpu/ccpr/GrCCPRTriangleShader.cpp b/src/gpu/ccpr/GrCCPRTriangleShader.cpp
index 1692b83ae1..ce05697dbf 100644
--- a/src/gpu/ccpr/GrCCPRTriangleShader.cpp
+++ b/src/gpu/ccpr/GrCCPRTriangleShader.cpp
@@ -10,29 +10,23 @@
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLVertexGeoBuilder.h"
 
-GrCCPRTriangleHullShader::WindHandling
-GrCCPRTriangleHullShader::onEmitVaryings(GrGLSLVaryingHandler*, SkString* code,
-                                         const char* /*position*/, const char* /*coverage*/,
-                                         const char* /*wind*/) {
-    return WindHandling::kNotHandled; // No varyings.Let the base class handle wind.
-}
-
-void GrCCPRTriangleHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
-                                                  const char* outputCoverage) const {
-    f->codeAppendf("%s = 1;", outputCoverage);
-}
-
-GrCCPRTriangleEdgeShader::WindHandling
-GrCCPRTriangleEdgeShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code,
-                                         const char* position, const char* coverage,
-                                         const char* wind) {
-    varyingHandler->addVarying("coverage_times_wind", &fCoverageTimesWind);
-    code->appendf("%s = %s * %s;", fCoverageTimesWind.gsOut(), coverage, wind);
+using Shader = GrCCPRCoverageProcessor::Shader;
+
+Shader::WindHandling GrCCPRTriangleShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
+                                                          SkString* code, const char* /*position*/,
+                                                          const char* coverage, const char* wind) {
+    if (!coverage) {
+        varyingHandler->addFlatVarying("wind", &fCoverageTimesWind);
+        code->appendf("%s = %s;", fCoverageTimesWind.gsOut(), wind);
+    } else {
+        varyingHandler->addVarying("coverage_times_wind", &fCoverageTimesWind);
+        code->appendf("%s = %s * %s;", fCoverageTimesWind.gsOut(), coverage, wind);
+    }
     return WindHandling::kHandled;
 }
 
-void GrCCPRTriangleEdgeShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
-                                                  const char* outputCoverage) const {
+void GrCCPRTriangleShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
+                                              const char* outputCoverage) const {
     f->codeAppendf("%s = %s;", outputCoverage, fCoverageTimesWind.fsIn());
 }
 
@@ -90,10 +84,12 @@ void GrCCPRTriangleCornerShader::emitSetupCode(GrGLSLVertexGeoBuilder* s, const
     s->codeAppend ("}");
 }
 
-GrCCPRTriangleCornerShader::WindHandling
+Shader::WindHandling
 GrCCPRTriangleCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code,
-                                           const char* position, const char* /*coverage*/,
+                                           const char* position, const char* coverage,
                                            const char* /*wind*/) {
+    SkASSERT(!coverage);
+
     varyingHandler->addVarying("corner_location_in_aa_boxes", &fCornerLocationInAABoxes);
     varyingHandler->addFlatVarying("bisect_in_aa_boxes", &fBisectInAABoxes);
     code->appendf("for (int i = 0; i < 2; ++i) {");
diff --git a/src/gpu/ccpr/GrCCPRTriangleShader.h b/src/gpu/ccpr/GrCCPRTriangleShader.h
index 4f7228a57a..1f58e84d78 100644
--- a/src/gpu/ccpr/GrCCPRTriangleShader.h
+++ b/src/gpu/ccpr/GrCCPRTriangleShader.h
@@ -11,22 +11,11 @@
 #include "ccpr/GrCCPRCoverageProcessor.h"
 
 /**
- * Pass 1: Draw the triangle's conservative raster hull with a coverage of 1. (Conservative raster
- *         is drawn by considering 3 pixel size boxes, one centered at each vertex, and drawing the
- *         convex hull of those boxes.)
+ * Passes 1 & 2: Draw the triangle's conservative raster hull with a coverage of 1, then smooth the
+ *               edges by drawing the conservative rasters of all 3 edges and interpolating from
+ *               coverage=-1 on the outside to coverage=0 on the inside.
  */
-class GrCCPRTriangleHullShader : public GrCCPRCoverageProcessor::Shader {
-    WindHandling onEmitVaryings(GrGLSLVaryingHandler*, SkString* code, const char* position,
-                                const char* coverage, const char* wind) override;
-    void onEmitFragmentCode(GrGLSLPPFragmentBuilder* f, const char* outputCoverage) const override;
-};
-
-/**
- * Pass 2: Smooth the edges that were over-rendered during Pass 1. Draw the conservative raster of
- *         each edge (i.e. convex hull of two pixel-size boxes at the endpoints), interpolating from
- *         coverage=-1 on the outside edge to coverage=0 on the inside edge.
- */
-class GrCCPRTriangleEdgeShader : public GrCCPRCoverageProcessor::Shader {
+class GrCCPRTriangleShader : public GrCCPRCoverageProcessor::Shader {
     WindHandling onEmitVaryings(GrGLSLVaryingHandler*, SkString* code, const char* position,
                                 const char* coverage, const char* wind) override;
     void onEmitFragmentCode(GrGLSLPPFragmentBuilder*, const char* outputCoverage) const override;