Fix various issues with instanced rendering precision

src/gpu/instanced/InstanceProcessor.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstanceProcessor.h"
 
 #include "GrContext.h"
@@ skipping 543 matching lines @@
 
     void onEmitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*, const char*,
                     const char*) override;
 
     typedef Backend INHERITED;
 };
 
 void GLSLInstanceProcessor::BackendNonAA::onInit(GrGLSLVaryingHandler* varyingHandler,
                                                  GrGLSLVertexBuilder*) {
     if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
-        varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kHigh_GrSLPrecision);
+        varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kLow_GrSLPrecision);
         varyingHandler->addVarying("arcCoords", &fArcCoords, kMedium_GrSLPrecision);
     }
 }
 
 void GLSLInstanceProcessor::BackendNonAA::setupRect(GrGLSLVertexBuilder* v) {
     if (fTriangleIsArc.vsOut()) {
         v->codeAppendf("%s = 0;", fTriangleIsArc.vsOut());
     }
 }
 
@@ skipping 156 matching lines @@
                                        kLow_GrSLPrecision);
             if (kRect_ShapeFlag == fBatchInfo.fShapeTypes) {
                 fColor = fColorTimesRectCoverage;
             }
         } else {
             varyingHandler->addVarying("rectCoverage", &fRectCoverage, kLow_GrSLPrecision);
         }
         v->codeAppend("float rectCoverage = 0.0;");
     }
     if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
-        varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kHigh_GrSLPrecision);
+        varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kLow_GrSLPrecision);
         if (!fShapeIsCircle) {
-            varyingHandler->addVarying("ellipseCoords", &fEllipseCoords, kHigh_GrSLPrecision);
+            varyingHandler->addVarying("ellipseCoords", &fEllipseCoords, kMedium_GrSLPrecision);
             varyingHandler->addFlatVarying("ellipseName", &fEllipseName, kHigh_GrSLPrecision);
         } else {
             varyingHandler->addVarying("circleCoords", &fEllipseCoords, kMedium_GrSLPrecision);
             varyingHandler->addFlatVarying("bloatedRadius", &fBloatedRadius, kMedium_GrSLPrecision);
         }
     }
 }
 
 void GLSLInstanceProcessor::BackendCoverage::setupRect(GrGLSLVertexBuilder* v) {
     // Make the border one pixel wide. Inner vs outer is indicated by coordAttrs.
@@ skipping 84 matching lines @@
                    fEllipseName.vsOut());
 }
 
 void GLSLInstanceProcessor::BackendCoverage::onInitInnerShape(GrGLSLVaryingHandler* varyingHandler,
                                                               GrGLSLVertexBuilder* v) {
     v->codeAppend("vec2 innerShapeHalfSize = shapeHalfSize / outer2Inner.xy;");
 
     if (kOval_ShapeFlag == fBatchInfo.fInnerShapeTypes) {
         varyingHandler->addVarying("innerEllipseCoords", &fInnerEllipseCoords,
                                    kMedium_GrSLPrecision);
-        varyingHandler->addFlatVarying("innerEllipseName", &fInnerEllipseName,
-                                       kMedium_GrSLPrecision);
+        varyingHandler->addFlatVarying("innerEllipseName", &fInnerEllipseName, kHigh_GrSLPrecision);
     } else {
         varyingHandler->addVarying("distanceToInnerEdge", &fDistanceToInnerEdge,
                                    kMedium_GrSLPrecision);
         varyingHandler->addFlatVarying("innerShapeBloatedHalfSize", &fInnerShapeBloatedHalfSize,
                                        kMedium_GrSLPrecision);
         if (kRect_ShapeFlag != fBatchInfo.fInnerShapeTypes) {
-            varyingHandler->addVarying("innerShapeCoords", &fInnerShapeCoords, kHigh_GrSLPrecision);
+            varyingHandler->addVarying("innerShapeCoords", &fInnerShapeCoords,
+                                       kMedium_GrSLPrecision);
             varyingHandler->addFlatVarying("innerEllipseName", &fInnerEllipseName,
-                                           kMedium_GrSLPrecision);
-            varyingHandler->addFlatVarying("innerRRect", &fInnerRRect, kHigh_GrSLPrecision);
+                                           kHigh_GrSLPrecision);
+            varyingHandler->addFlatVarying("innerRRect", &fInnerRRect, kMedium_GrSLPrecision);
         }
     }
 }
 
 void GLSLInstanceProcessor::BackendCoverage::setupInnerRect(GrGLSLVertexBuilder* v) {
     if (fInnerRRect.vsOut()) {
         // The fragment shader will generalize every inner shape as a round rect. Since this one
         // is a rect, we simply emit bogus parameters for the round rect (effectively negative
         // radii) that ensure the fragment shader always takes the "emitRect" codepath.
         v->codeAppendf("%s.xy = abs(outer2Inner.xy) * (1.0 + bloat) + abs(outer2Inner.zw);",
@@ skipping 75 matching lines @@
                           innerCoverageDecl.c_str());
         } else {
             v->codeAppendf("%s = innerShapeCoords * innerShapeHalfSize;",
                            fDistanceToInnerEdge.vsOut());
             v->codeAppendf("%s = innerShapeHalfSize + 0.5;", fInnerShapeBloatedHalfSize.vsOut());
 
             if (kRect_ShapeFlag == fBatchInfo.fInnerShapeTypes) {
                 this->emitInnerRect(f, innerCoverageDecl.c_str());
             } else {
                 f->codeAppendf("%s = 0.0;", innerCoverageDecl.c_str());
+                f->appendPrecisionModifier(kMedium_GrSLPrecision);
                 f->codeAppendf("vec2 distanceToArcEdge = abs(%s) - %s.xy;",
                                fInnerShapeCoords.fsIn(), fInnerRRect.fsIn());
                 f->codeAppend ("if (any(lessThan(distanceToArcEdge, vec2(1e-5)))) {");
                 this->emitInnerRect(f, "innerCoverage");
                 f->codeAppend ("} else {");
+                f->appendPrecisionModifier(kMedium_GrSLPrecision);
                 f->codeAppendf(    "vec2 ellipseCoords = distanceToArcEdge * %s.zw;",
                                    fInnerRRect.fsIn());
                 this->emitArc(f, "ellipseCoords", fInnerEllipseName.fsIn(),
                               false /*ellipseCoordsNeedClamp*/,
                               false /*ellipseCoordsMayBeNegative*/, "innerCoverage");
                 f->codeAppend ("}");
             }
         }
         f->codeAppendf("%s = vec4(max(coverage - innerCoverage, 0.0));", outCoverage);
     } else if (!fTweakAlphaForCoverage) {
@@ skipping 13 matching lines @@
         f->codeAppendf("%s = %s;", outCoverage, fRectCoverage.fsIn());
     } else {
         f->codeAppendf("%s = 1.0;", outCoverage);
     }
 }
 
 void GLSLInstanceProcessor::BackendCoverage::emitCircle(GrGLSLPPFragmentBuilder* f,
                                                         const char* outCoverage) {
     // TODO: circleCoords = max(circleCoords, 0) if we decide to do this optimization on rrects.
     SkASSERT(!(kRRect_ShapesMask & fBatchInfo.fShapeTypes));
+    f->appendPrecisionModifier(kLow_GrSLPrecision);
     f->codeAppendf("float distanceToEdge = %s - length(%s);",
                    fBloatedRadius.fsIn(), fEllipseCoords.fsIn());
     f->codeAppendf("%s = clamp(distanceToEdge, 0.0, 1.0);", outCoverage);
 }
 
 void GLSLInstanceProcessor::BackendCoverage::emitArc(GrGLSLPPFragmentBuilder* f,
                                                      const char* ellipseCoords,
                                                      const char* ellipseName,
                                                      bool ellipseCoordsNeedClamp,
                                                      bool ellipseCoordsMayBeNegative,
                                                      const char* outCoverage) {
     SkASSERT(!ellipseCoordsMayBeNegative || ellipseCoordsNeedClamp);
     if (ellipseCoordsNeedClamp) {
         // This serves two purposes:
         //  - To restrict the arcs of rounded rects to their positive quadrants.
         //  - To avoid inversesqrt(0) in the ellipse formula.
+        f->appendPrecisionModifier(kMedium_GrSLPrecision);
         if (ellipseCoordsMayBeNegative) {
             f->codeAppendf("vec2 ellipseClampedCoords = max(abs(%s), vec2(1e-4));", ellipseCoords);
         } else {
             f->codeAppendf("vec2 ellipseClampedCoords = max(%s, vec2(1e-4));", ellipseCoords);
         }
         ellipseCoords = "ellipseClampedCoords";
     }
     // ellipseCoords are in pixel space and ellipseName is 1 / rx^2, 1 / ry^2.
+    f->appendPrecisionModifier(kHigh_GrSLPrecision);
     f->codeAppendf("vec2 Z = %s * %s;", ellipseCoords, ellipseName);
     // implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
+    f->appendPrecisionModifier(kHigh_GrSLPrecision);
     f->codeAppendf("float implicit = dot(Z, %s) - 1.0;", ellipseCoords);
     // gradDot is the squared length of the gradient of the implicit.
+    f->appendPrecisionModifier(kHigh_GrSLPrecision);
     f->codeAppendf("float gradDot = 4.0 * dot(Z, Z);");
-    f->appendPrecisionModifier(kLow_GrSLPrecision);
+    f->appendPrecisionModifier(kMedium_GrSLPrecision);
     f->codeAppend ("float approxDist = implicit * inversesqrt(gradDot);");
     f->codeAppendf("%s = clamp(0.5 - approxDist, 0.0, 1.0);", outCoverage);
 }
 
 void GLSLInstanceProcessor::BackendCoverage::emitInnerRect(GrGLSLPPFragmentBuilder* f,
                                                            const char* outCoverage) {
     f->appendPrecisionModifier(kLow_GrSLPrecision);
     f->codeAppendf("vec2 c = %s - abs(%s);",
                    fInnerShapeBloatedHalfSize.fsIn(), fDistanceToInnerEdge.fsIn());
     f->codeAppendf("%s = clamp(min(c.x, c.y), 0.0, 1.0);", outCoverage);
@@ skipping 72 matching lines @@
     GrGLSLVertToFrag   fFragInnerShapeHalfSpan;
     SkString           fSquareFun;
 
     typedef Backend INHERITED;
 };
 
 void GLSLInstanceProcessor::BackendMultisample::onInit(GrGLSLVaryingHandler* varyingHandler,
                                                        GrGLSLVertexBuilder* v) {
     if (!this->isMixedSampled()) {
         if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
-            varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc,
-                                           kHigh_GrSLPrecision);
+            varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kLow_GrSLPrecision);
             varyingHandler->addVarying("arcCoords", &fArcCoords, kHigh_GrSLPrecision);
             if (!fBatchInfo.fHasPerspective) {
                 varyingHandler->addFlatVarying("arcInverseMatrix", &fArcInverseMatrix,
                                                kHigh_GrSLPrecision);
                 varyingHandler->addFlatVarying("fragArcHalfSpan", &fFragArcHalfSpan,
                                                kHigh_GrSLPrecision);
             }
         } else if (!fBatchInfo.fInnerShapeTypes) {
             return;
         }
@@ skipping 13 matching lines @@
                                                kHigh_GrSLPrecision);
                 varyingHandler->addFlatVarying("fragArcHalfSpan", &fFragArcHalfSpan,
                                                kHigh_GrSLPrecision);
             }
         } else if (fBatchInfo.fShapeTypes & kOval_ShapeFlag) {
             fArcCoords = fShapeCoords;
             fArcInverseMatrix = fShapeInverseMatrix;
             fFragArcHalfSpan = fFragShapeHalfSpan;
             if (fBatchInfo.fShapeTypes & kRect_ShapeFlag) {
                 varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc,
-                                               kHigh_GrSLPrecision);
+                                               kLow_GrSLPrecision);
             }
         }
         if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
            v->definef("SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
            varyingHandler->addFlatVarying("earlyAccept", &fEarlyAccept, kHigh_GrSLPrecision);
         }
     }
     if (!fBatchInfo.fHasPerspective) {
         v->codeAppend("mat2 shapeInverseMatrix = inverse(mat2(shapeMatrix));");
         v->codeAppend("vec2 fragShapeSpan = abs(vec4(shapeInverseMatrix).xz) + "
@@ skipping 926 matching lines @@
 
         case kCorneredRect_FirstIndex: return "basic_round_rect";
         case kCorneredFramedRect_FirstIndex: return "coverage_round_rect";
         case kCorneredRectFanned_FirstIndex: return "mixed_samples_round_rect";
 
         default: return "unknown";
     }
 }
 
 }