Address CCPR TODOs now that we are in device space

Bug: skia:
Change-Id: I48619e93108bdbe453155be4f9da821ff0397ee3
Reviewed-on: https://skia-review.googlesource.com/63400
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

8 files changed, 22 insertions, 57 deletions

diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
index e4cabf75f3..1dc129f2ba 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
@@ -76,18 +76,13 @@ void GrCCPRCoverageProcessor::Shader::EmitEdgeDistanceEquation(GrGLSLShaderBuild
                                                                const char* leftPt,
                                                                const char* rightPt,
                                                                const char* outputDistanceEquation) {
-    // Which quadrant does the vector from left -> right fall into?
-    s->codeAppendf("float2 qlr = sign(%s - %s);", rightPt, leftPt);
-    s->codeAppend ("float2 d1 = float2(qlr.y, -qlr.x);");
-
     s->codeAppendf("float2 n = float2(%s.y - %s.y, %s.x - %s.x);",
                    rightPt, leftPt, leftPt, rightPt);
-    s->codeAppendf("float2 kk = n * float2x2(%s + bloat * d1, %s - bloat * d1);",
-                   leftPt, leftPt);
-    // Clamp for when n=0. wind=0 when n=0 so as long as we don't get Inf or NaN we are fine.
-    s->codeAppendf("float scale = 1 / max(kk[0] - kk[1], 1e-30);");
-
-    s->codeAppendf("%s = half3(-n, kk[1]) * scale;", outputDistanceEquation);
+    s->codeAppend ("float nwidth = (abs(n.x) + abs(n.y)) * (bloat * 2);");
+    // When nwidth=0, wind must also be 0 (and coverage * wind = 0). So it doesn't matter what we
+    // come up with here as long as it isn't NaN or Inf.
+    s->codeAppend ("n /= (0 != nwidth) ? nwidth : 1;");
+    s->codeAppendf("%s = float3(-n, dot(n, %s) - .5);", outputDistanceEquation, leftPt);
 }
 
 int GrCCPRCoverageProcessor::Shader::DefineSoftSampleLocations(GrGLSLPPFragmentBuilder* f,
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.h b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
index 17aaba59f0..9c5d6901f9 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.h
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
@@ -153,7 +153,8 @@ public:
                               const char* skOutputColor, const char* skOutputCoverage) const;
 
         // Defines an equation ("dot(float3(pt, 1), distance_equation)") that is -1 on the outside
-        // border of a conservative raster edge and 0 on the inside (see emitEdgeGeometry).
+        // border of a conservative raster edge and 0 on the inside. 'leftPt' and 'rightPt' must be
+        // ordered clockwise.
         static void EmitEdgeDistanceEquation(GrGLSLShaderBuilder*, const char* leftPt,
                                              const char* rightPt,
                                              const char* outputDistanceEquation);
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
index f501c3d1c8..5286a29508 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
@@ -211,12 +211,13 @@ public:
 
         Shader::EmitEdgeDistanceEquation(g, "left", "right", "float3 edge_distance_equation");
 
-        // qlr is defined in EmitEdgeDistanceEquation. TODO: address in a followup CL!
+        // Which quadrant does the vector from left -> right fall into?
+        g->codeAppend ("float2 qlr = sign(right - left);");
         g->codeAppend ("float2x2 outer_pts = float2x2(left - bloat * qlr, right + bloat * qlr);");
         g->codeAppend ("half2 outer_coverage = edge_distance_equation.xy * outer_pts + "
                                               "edge_distance_equation.z;");
 
-        // d1 is defined in EmitEdgeDistanceEquation. TODO: address in a followup CL!
+        g->codeAppend ("float2 d1 = float2(qlr.y, -qlr.x);");
         g->codeAppend ("float2 d2 = d1;");
         g->codeAppend ("bool aligned = qlr.x == 0 || qlr.y == 0;");
         g->codeAppend ("if (aligned) {");
diff --git a/src/gpu/ccpr/GrCCPRCubicShader.cpp b/src/gpu/ccpr/GrCCPRCubicShader.cpp
index 3a820d7a7b..62d9a838b0 100644
--- a/src/gpu/ccpr/GrCCPRCubicShader.cpp
+++ b/src/gpu/ccpr/GrCCPRCubicShader.cpp
@@ -92,15 +92,6 @@ void GrCCPRCubicShader::emitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
                                   "0, orientation[0], 0, "
                                   "0, 0, orientation[1]);", fKLMMatrix.c_str());
 
-    // TODO: remove in followup CL.
-    s->declareGlobal(fKLMDerivatives);
-    s->codeAppendf("%s[0] = %s[0].xy;",
-                   fKLMDerivatives.c_str(), fKLMMatrix.c_str());
-    s->codeAppendf("%s[1] = %s[1].xy;",
-                   fKLMDerivatives.c_str(), fKLMMatrix.c_str());
-    s->codeAppendf("%s[2] = %s[2].xy;",
-                   fKLMDerivatives.c_str(), fKLMMatrix.c_str());
-
     // Determine the amount of additional coverage to subtract out for the flat edge (P3 -> P0).
     s->declareGlobal(fEdgeDistanceEquation);
     s->codeAppendf("short edgeidx0 = %s > 0 ? 3 : 0;", wind);
@@ -133,9 +124,9 @@ void GrCCPRCubicHullShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char*
 void GrCCPRCubicHullShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code) {
     // "klm" was just defined by the base class.
     varyingHandler->addVarying("grad_matrix", &fGradMatrix);
-    code->appendf("%s[0] = 3 * klm[0] * %s[0];", fGradMatrix.gsOut(), fKLMDerivatives.c_str());
+    code->appendf("%s[0] = 3 * klm[0] * %s[0].xy;", fGradMatrix.gsOut(), fKLMMatrix.c_str());
     code->appendf("%s[1] = -klm[1] * %s[2].xy - klm[2] * %s[1].xy;",
-                    fGradMatrix.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str());
+                    fGradMatrix.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str());
 }
 
 void GrCCPRCubicHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
@@ -150,11 +141,6 @@ void GrCCPRCubicHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
 
 void GrCCPRCubicCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
                                               const char* cornerId, GeometryVars* vars) const {
-    // TODO: remove in followup CL.
-    s->declareGlobal(fEdgeDistanceDerivatives);
-    s->codeAppendf("%s = %s.xy;",
-                   fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str());
-
     s->codeAppendf("float2 corner = %s[%s * 3];", pts, cornerId);
     vars->fCornerVars.fPoint = "corner";
 }
@@ -162,13 +148,13 @@ void GrCCPRCubicCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char
 void GrCCPRCubicCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code) {
     varyingHandler->addFlatVarying("dklmddx", &fdKLMDdx);
     code->appendf("%s = float4(%s[0].x, %s[1].x, %s[2].x, %s.x);",
-                    fdKLMDdx.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
-                    fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
+                  fdKLMDdx.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str(),
+                  fKLMMatrix.c_str(), fEdgeDistanceEquation.c_str());
 
     varyingHandler->addFlatVarying("dklmddy", &fdKLMDdy);
     code->appendf("%s = float4(%s[0].y, %s[1].y, %s[2].y, %s.y);",
-                    fdKLMDdy.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
-                    fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
+                  fdKLMDdy.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str(),
+                  fKLMMatrix.c_str(), fEdgeDistanceEquation.c_str());
 }
 
 void GrCCPRCubicCornerShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
diff --git a/src/gpu/ccpr/GrCCPRCubicShader.h b/src/gpu/ccpr/GrCCPRCubicShader.h
index eae2a206ff..a6d597d3c8 100644
--- a/src/gpu/ccpr/GrCCPRCubicShader.h
+++ b/src/gpu/ccpr/GrCCPRCubicShader.h
@@ -52,7 +52,6 @@ protected:
 
     const CubicType   fCubicType;
     GrShaderVar       fKLMMatrix{"klm_matrix", kFloat3x3_GrSLType};
-    GrShaderVar       fKLMDerivatives{"klm_derivatives", kFloat2_GrSLType, 3};
     GrShaderVar       fEdgeDistanceEquation{"edge_distance_equation", kFloat3_GrSLType};
     GrGLSLGeoToFrag   fKLMD{kFloat4_GrSLType};
 };
@@ -84,7 +83,6 @@ private:
     void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) override;
     void onEmitFragmentCode(GrGLSLPPFragmentBuilder*, const char* outputCoverage) const override;
 
-    GrShaderVar        fEdgeDistanceDerivatives{"edge_distance_derivatives", kFloat2_GrSLType};
     GrGLSLGeoToFrag    fdKLMDdx{kFloat4_GrSLType};
     GrGLSLGeoToFrag    fdKLMDdy{kFloat4_GrSLType};
 };
diff --git a/src/gpu/ccpr/GrCCPRQuadraticShader.cpp b/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
index 126dae15cd..bdef285f1a 100644
--- a/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
+++ b/src/gpu/ccpr/GrCCPRQuadraticShader.cpp
@@ -45,11 +45,6 @@ void GrCCPRQuadraticShader::emitSetupCode(GrGLSLShaderBuilder* s, const char* pt
                                          "%s[2], 1));",
                    fCanonicalMatrix.c_str(), pts, pts, pts);
 
-    // TODO: remove in followup CL.
-    s->declareGlobal(fCanonicalDerivatives);
-    s->codeAppendf("%s = float2x2(%s);",
-                   fCanonicalDerivatives.c_str(), fCanonicalMatrix.c_str());
-
     s->declareGlobal(fEdgeDistanceEquation);
     s->codeAppendf("float2 edgept0 = %s[%s > 0 ? 2 : 0];", pts, wind);
     s->codeAppendf("float2 edgept1 = %s[%s > 0 ? 0 : 2];", pts, wind);
@@ -94,8 +89,8 @@ void GrCCPRQuadraticHullShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const ch
 void GrCCPRQuadraticHullShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
                                                SkString* code) {
     varyingHandler->addVarying("grad", &fGrad);
-    code->appendf("%s = float2(2 * %s.x, -1) * %s;",
-                  fGrad.gsOut(), fXYD.gsOut(), fCanonicalDerivatives.c_str());
+    code->appendf("%s = float2(2 * %s.x, -1) * float2x2(%s);",
+                  fGrad.gsOut(), fXYD.gsOut(), fCanonicalMatrix.c_str());
 }
 
 void GrCCPRQuadraticHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
@@ -108,11 +103,6 @@ void GrCCPRQuadraticHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
 
 void GrCCPRQuadraticCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
                                                   const char* cornerId, GeometryVars* vars) const {
-    // TODO: remove in followup CL.
-    s->declareGlobal(fEdgeDistanceDerivatives);
-    s->codeAppendf("%s = %s.xy;",
-                   fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str());
-
     s->codeAppendf("float2 corner = %s[%s * 2];", pts, cornerId);
     vars->fCornerVars.fPoint = "corner";
 }
@@ -121,13 +111,13 @@ void GrCCPRQuadraticCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHa
                                                  SkString* code) {
     varyingHandler->addFlatVarying("dXYDdx", &fdXYDdx);
     code->appendf("%s = float3(%s[0].x, %s[0].y, %s.x);",
-                  fdXYDdx.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
-                  fEdgeDistanceDerivatives.c_str());
+                  fdXYDdx.gsOut(), fCanonicalMatrix.c_str(), fCanonicalMatrix.c_str(),
+                  fEdgeDistanceEquation.c_str());
 
     varyingHandler->addFlatVarying("dXYDdy", &fdXYDdy);
     code->appendf("%s = float3(%s[1].x, %s[1].y, %s.y);",
-                  fdXYDdy.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
-                  fEdgeDistanceDerivatives.c_str());
+                  fdXYDdy.gsOut(), fCanonicalMatrix.c_str(), fCanonicalMatrix.c_str(),
+                  fEdgeDistanceEquation.c_str());
 }
 
 void GrCCPRQuadraticCornerShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
diff --git a/src/gpu/ccpr/GrCCPRQuadraticShader.h b/src/gpu/ccpr/GrCCPRQuadraticShader.h
index 8511c51531..38dd14e737 100644
--- a/src/gpu/ccpr/GrCCPRQuadraticShader.h
+++ b/src/gpu/ccpr/GrCCPRQuadraticShader.h
@@ -42,7 +42,6 @@ protected:
     virtual void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) = 0;
 
     const GrShaderVar   fCanonicalMatrix{"canonical_matrix", kFloat3x3_GrSLType};
-    const GrShaderVar   fCanonicalDerivatives{"canonical_derivatives", kFloat2x2_GrSLType};
     const GrShaderVar   fEdgeDistanceEquation{"edge_distance_equation", kFloat3_GrSLType};
     GrGLSLGeoToFrag     fXYD{kFloat3_GrSLType};
 };
@@ -77,7 +76,6 @@ class GrCCPRQuadraticCornerShader : public GrCCPRQuadraticShader {
     void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) override;
     void onEmitFragmentCode(GrGLSLPPFragmentBuilder*, const char* outputCoverage) const override;
 
-    const GrShaderVar   fEdgeDistanceDerivatives{"edge_distance_derivatives", kFloat2_GrSLType};
     GrGLSLGeoToFrag     fdXYDdx{kFloat3_GrSLType};
     GrGLSLGeoToFrag     fdXYDdy{kFloat3_GrSLType};
 };
diff --git a/src/gpu/ccpr/GrCCPRTriangleShader.cpp b/src/gpu/ccpr/GrCCPRTriangleShader.cpp
index 8db3b637e4..a1f4198f86 100644
--- a/src/gpu/ccpr/GrCCPRTriangleShader.cpp
+++ b/src/gpu/ccpr/GrCCPRTriangleShader.cpp
@@ -91,11 +91,7 @@ void GrCCPRTriangleCornerShader::emitSetupCode(GrGLSLShaderBuilder* s, const cha
     s->codeAppendf(    "%s[i][0] = -dot(n, corner) + .5;", fAABoxTranslates.c_str());
 
     // The Y component runs perpendicular to the edge (i.e. distance-to-edge).
-    // NOTE: if we are back in device space and bloat.x == bloat.y, we will not need to find and
-    // divide by nwidth a second time.
     s->codeAppend (    "n = (i == 0) ? float2(-n.y, n.x) : float2(n.y, -n.x);");
-    s->codeAppend (    "nwidth = (abs(n.x) + abs(n.y)) * (bloat * 2);");
-    s->codeAppend (    "n /= nwidth;");
     s->codeAppendf(    "%s[i][1] = n;", fAABoxMatrices.c_str());
     s->codeAppendf(    "%s[i][1] = -dot(n, corner) + .5;", fAABoxTranslates.c_str());