Replace switch statements in instanced vertex shaders

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 129 matching lines @@
 };
 
 class GLSLInstanceProcessor::Backend {
 public:
     static Backend* SK_WARN_UNUSED_RESULT Create(const GrPipeline&, BatchInfo, const VertexInputs&);
     virtual ~Backend() {}
 
     void init(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
     virtual void setupRect(GrGLSLVertexBuilder*) = 0;
     virtual void setupOval(GrGLSLVertexBuilder*) = 0;
-    void setupRRect(GrGLSLVertexBuilder*);
+    void setupRRect(GrGLSLVertexBuilder*, int* usedShapeDefinitions);
 
     void initInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
     virtual void setupInnerRect(GrGLSLVertexBuilder*) = 0;
     virtual void setupInnerOval(GrGLSLVertexBuilder*) = 0;
-    void setupInnerRRect(GrGLSLVertexBuilder*);
+    void setupInnerSimpleRRect(GrGLSLVertexBuilder*);
 
     const char* outShapeCoords() {
         return fModifiedShapeCoords ? fModifiedShapeCoords : fInputs.attr(Attrib::kShapeCoords);
     }
 
     void emitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*, const char* outCoverage,
                   const char* outColor);
 
 protected:
     Backend(BatchInfo batchInfo, const VertexInputs& inputs)
@@ skipping 11 matching lines @@
         if (fBatchInfo.fShapeTypes & kRRect_ShapesMask) {
             fModifiedShapeCoords = "adjustedShapeCoords";
         }
     }
 
     virtual void onInit(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) = 0;
     virtual void adjustRRectVertices(GrGLSLVertexBuilder*);
     virtual void onSetupRRect(GrGLSLVertexBuilder*) {}
 
     virtual void onInitInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) = 0;
-    virtual void onSetupInnerRRect(GrGLSLVertexBuilder*) = 0;
+    virtual void onSetupInnerSimpleRRect(GrGLSLVertexBuilder*) = 0;
 
     virtual void onEmitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*,
                             const char* outCoverage, const char* outColor) = 0;
 
     void setupSimpleRadii(GrGLSLVertexBuilder*);
     void setupNinePatchRadii(GrGLSLVertexBuilder*);
     void setupComplexRadii(GrGLSLVertexBuilder*);
 
     const BatchInfo       fBatchInfo;
     const VertexInputs&   fInputs;
@@ skipping 32 matching lines @@
         v->codeAppendf("mat3 shapeMatrix = mat3(%s, %s, vec3(0, 0, 1));",
                        inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
         v->codeAppendf("if (0u != (%s & PERSPECTIVE_FLAG)) {",
                        inputs.attr(Attrib::kInstanceInfo));
         v->codeAppend (    "shapeMatrix[2] = ");
         inputs.fetchNextParam(kVec3f_GrSLType);
         v->codeAppend (    ";");
         v->codeAppend ("}");
     }
 
-    int usedShapeTypes = 0;
-
     bool hasSingleShapeType = SkIsPow2(ip.batchInfo().fShapeTypes);
     if (!hasSingleShapeType) {
-        usedShapeTypes |= ip.batchInfo().fShapeTypes;
         v->define("SHAPE_TYPE_BIT", kShapeType_InfoBit);
         v->codeAppendf("uint shapeType = %s >> SHAPE_TYPE_BIT;",
                        inputs.attr(Attrib::kInstanceInfo));
     }
 
     SkAutoTDelete<Backend> backend(Backend::Create(pipeline, ip.batchInfo(), inputs));
     backend->init(varyingHandler, v);
 
-    if (hasSingleShapeType) {
+    int usedShapeDefinitions = 0;
+
+    if (hasSingleShapeType || !(ip.batchInfo().fShapeTypes & ~kRRect_ShapesMask)) {
         if (kRect_ShapeFlag == ip.batchInfo().fShapeTypes) {
             backend->setupRect(v);
         } else if (kOval_ShapeFlag == ip.batchInfo().fShapeTypes) {
             backend->setupOval(v);
         } else {
-            backend->setupRRect(v);
+            backend->setupRRect(v, &usedShapeDefinitions);
         }
     } else {
-        v->codeAppend ("switch (shapeType) {");
-        if (ip.batchInfo().fShapeTypes & kRect_ShapeFlag) {
-            v->codeAppend ("case RECT_SHAPE_TYPE: {");
-            backend->setupRect(v);
-            v->codeAppend ("} break;");
+        if (ip.batchInfo().fShapeTypes & kRRect_ShapesMask) {
+            v->codeAppend ("if (shapeType >= SIMPLE_R_RECT_SHAPE_TYPE) {");
+            backend->setupRRect(v, &usedShapeDefinitions);
+            v->codeAppend ("}");
+            usedShapeDefinitions |= kSimpleRRect_ShapeFlag;
         }
         if (ip.batchInfo().fShapeTypes & kOval_ShapeFlag) {
-            v->codeAppend ("case OVAL_SHAPE_TYPE: {");
+            if (ip.batchInfo().fShapeTypes & kRect_ShapeFlag) {
+                if (ip.batchInfo().fShapeTypes & kRRect_ShapesMask) {
+                    v->codeAppend ("else ");
+                }
+                v->codeAppend ("if (OVAL_SHAPE_TYPE == shapeType) {");
+                usedShapeDefinitions |= kOval_ShapeFlag;
+            } else {
+                v->codeAppend ("else {");
+            }
             backend->setupOval(v);
-            v->codeAppend ("} break;");
+            v->codeAppend ("}");
         }
-        if (ip.batchInfo().fShapeTypes & kRRect_ShapesMask) {
-            v->codeAppend ("default: {");
-            backend->setupRRect(v);
-            v->codeAppend ("} break;");
+        if (ip.batchInfo().fShapeTypes & kRect_ShapeFlag) {
+            v->codeAppend ("else {");
+            backend->setupRect(v);
+            v->codeAppend ("}");
         }
-        v->codeAppend ("}");
     }
 
     if (ip.batchInfo().fInnerShapeTypes) {
         bool hasSingleInnerShapeType = SkIsPow2(ip.batchInfo().fInnerShapeTypes);
         if (!hasSingleInnerShapeType) {
-            usedShapeTypes |= ip.batchInfo().fInnerShapeTypes;
             v->definef("INNER_SHAPE_TYPE_MASK", "0x%xu", kInnerShapeType_InfoMask);
             v->define("INNER_SHAPE_TYPE_BIT", kInnerShapeType_InfoBit);
             v->codeAppendf("uint innerShapeType = ((%s & INNER_SHAPE_TYPE_MASK) >> "
                                                   "INNER_SHAPE_TYPE_BIT);",
                            inputs.attr(Attrib::kInstanceInfo));
         }
         // Here we take advantage of the fact that outerRect == localRect in recordDRRect.
         v->codeAppendf("vec4 outer = %s;", inputs.attr(Attrib::kLocalRect));
         v->codeAppend ("vec4 inner = ");
         inputs.fetchNextParam();
         v->codeAppend (";");
         // outer2Inner is a transform from shape coords to inner shape coords:
         // e.g. innerShapeCoords = shapeCoords * outer2Inner.xy + outer2Inner.zw
         v->codeAppend ("vec4 outer2Inner = vec4(outer.zw - outer.xy, "
                                                "outer.xy + outer.zw - inner.xy - inner.zw) / "
                                                "(inner.zw - inner.xy).xyxy;");
         v->codeAppendf("vec2 innerShapeCoords = %s * outer2Inner.xy + outer2Inner.zw;",
                        backend->outShapeCoords());
 
         backend->initInnerShape(varyingHandler, v);
 
+        SkASSERT(0 == (ip.batchInfo().fInnerShapeTypes & kRRect_ShapesMask) ||
+                 kSimpleRRect_ShapeFlag == (ip.batchInfo().fInnerShapeTypes & kRRect_ShapesMask));
+
         if (hasSingleInnerShapeType) {
             if (kRect_ShapeFlag == ip.batchInfo().fInnerShapeTypes) {
                 backend->setupInnerRect(v);
             } else if (kOval_ShapeFlag == ip.batchInfo().fInnerShapeTypes) {
                 backend->setupInnerOval(v);
             } else {
-                backend->setupInnerRRect(v);
+                backend->setupInnerSimpleRRect(v);
             }
         } else {
-            v->codeAppend("switch (innerShapeType) {");
-            if (ip.batchInfo().fInnerShapeTypes & kRect_ShapeFlag) {
-                v->codeAppend("case RECT_SHAPE_TYPE: {");
-                backend->setupInnerRect(v);
-                v->codeAppend("} break;");
+            if (ip.batchInfo().fInnerShapeTypes & kSimpleRRect_ShapeFlag) {
+                v->codeAppend ("if (SIMPLE_R_RECT_SHAPE_TYPE == innerShapeType) {");
+                backend->setupInnerSimpleRRect(v);
+                v->codeAppend("}");
+                usedShapeDefinitions |= kSimpleRRect_ShapeFlag;
             }
             if (ip.batchInfo().fInnerShapeTypes & kOval_ShapeFlag) {
-                v->codeAppend("case OVAL_SHAPE_TYPE: {");
+                if (ip.batchInfo().fInnerShapeTypes & kRect_ShapeFlag) {
+                    if (ip.batchInfo().fInnerShapeTypes & kSimpleRRect_ShapeFlag) {
+                        v->codeAppend ("else ");
+                    }
+                    v->codeAppend ("if (OVAL_SHAPE_TYPE == innerShapeType) {");
+                    usedShapeDefinitions |= kOval_ShapeFlag;
+                } else {
+                    v->codeAppend ("else {");
+                }
                 backend->setupInnerOval(v);
-                v->codeAppend("} break;");
+                v->codeAppend("}");
             }
-            if (ip.batchInfo().fInnerShapeTypes & kRRect_ShapesMask) {
-                v->codeAppend("default: {");
-                backend->setupInnerRRect(v);
-                v->codeAppend("} break;");
+            if (ip.batchInfo().fInnerShapeTypes & kRect_ShapeFlag) {
+                v->codeAppend("else {");
+                backend->setupInnerRect(v);
+                v->codeAppend("}");
             }
-            v->codeAppend("}");
         }
     }
 
-    if (usedShapeTypes & kRect_ShapeFlag) {
-        v->definef("RECT_SHAPE_TYPE", "%du", (int)ShapeType::kRect);
-    }
-    if (usedShapeTypes & kOval_ShapeFlag) {
+    if (usedShapeDefinitions & kOval_ShapeFlag) {
         v->definef("OVAL_SHAPE_TYPE", "%du", (int)ShapeType::kOval);
     }
+    if (usedShapeDefinitions & kSimpleRRect_ShapeFlag) {
+        v->definef("SIMPLE_R_RECT_SHAPE_TYPE", "%du", (int)ShapeType::kSimpleRRect);
+    }
+    if (usedShapeDefinitions & kNinePatch_ShapeFlag) {
+        v->definef("NINE_PATCH_SHAPE_TYPE", "%du", (int)ShapeType::kNinePatch);
+    }
+    SkASSERT(!(usedShapeDefinitions & (kRect_ShapeFlag | kComplexRRect_ShapeFlag)));
 
     backend->emitCode(v, f, pipeline.ignoresCoverage() ? nullptr : args.fOutputCoverage,
                       args.fOutputColor);
 
     const char* localCoords = nullptr;
     if (ip.batchInfo().fUsesLocalCoords) {
         localCoords = "localCoords";
         v->codeAppendf("vec2 t = 0.5 * (%s + vec2(1));", backend->outShapeCoords());
         v->codeAppendf("vec2 localCoords = (1.0 - t) * %s.xy + t * %s.zw;",
                        inputs.attr(Attrib::kLocalRect), inputs.attr(Attrib::kLocalRect));
@@ skipping 35 matching lines @@
     }
 
     this->onInit(varyingHandler, v);
 
     if (!fColor.vsOut()) {
         varyingHandler->addFlatVarying("color", &fColor, kLow_GrSLPrecision);
         v->codeAppendf("%s = %s;", fColor.vsOut(), fInputs.attr(Attrib::kColor));
     }
 }
 
-void GLSLInstanceProcessor::Backend::setupRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::Backend::setupRRect(GrGLSLVertexBuilder* v, int* usedShapeDefinitions) {
     v->codeAppendf("uvec2 corner = uvec2(%s & 1, (%s >> 1) & 1);",
                    fInputs.attr(Attrib::kVertexAttrs), fInputs.attr(Attrib::kVertexAttrs));
     v->codeAppend ("vec2 cornerSign = vec2(corner) * 2.0 - 1.0;");
     v->codeAppendf("vec2 radii%s;", fNeedsNeighborRadii ? ", neighborRadii" : "");
     v->codeAppend ("mat2 p = ");
     fInputs.fetchNextParam(kMat22f_GrSLType);
     v->codeAppend (";");
     uint8_t types = fBatchInfo.fShapeTypes & kRRect_ShapesMask;
     if (0 == (types & (types - 1))) {
         if (kSimpleRRect_ShapeFlag == types) {
             this->setupSimpleRadii(v);
         } else if (kNinePatch_ShapeFlag == types) {
             this->setupNinePatchRadii(v);
         } else if (kComplexRRect_ShapeFlag == types) {
             this->setupComplexRadii(v);
         }
     } else {
-        v->codeAppend("switch (shapeType) {");
         if (types & kSimpleRRect_ShapeFlag) {
-            v->definef("SIMPLE_R_RECT_SHAPE_TYPE", "%du", (int)ShapeType::kSimpleRRect);
-            v->codeAppend ("case SIMPLE_R_RECT_SHAPE_TYPE: {");
+            v->codeAppend ("if (SIMPLE_R_RECT_SHAPE_TYPE == shapeType) {");
             this->setupSimpleRadii(v);
-            v->codeAppend ("} break;");
+            v->codeAppend ("}");
+            *usedShapeDefinitions |= kSimpleRRect_ShapeFlag;
         }
         if (types & kNinePatch_ShapeFlag) {
-            v->definef("NINE_PATCH_SHAPE_TYPE", "%du", (int)ShapeType::kNinePatch);
-            v->codeAppend ("case NINE_PATCH_SHAPE_TYPE: {");
+            if (types & kComplexRRect_ShapeFlag) {
+                if (types & kSimpleRRect_ShapeFlag) {
+                    v->codeAppend ("else ");
+                }
+                v->codeAppend ("if (NINE_PATCH_SHAPE_TYPE == shapeType) {");
+                *usedShapeDefinitions |= kNinePatch_ShapeFlag;
+            } else {
+                v->codeAppend ("else {");
+            }
             this->setupNinePatchRadii(v);
-            v->codeAppend ("} break;");
+            v->codeAppend ("}");
         }
         if (types & kComplexRRect_ShapeFlag) {
-            v->codeAppend ("default: {");
+            v->codeAppend ("else {");
             this->setupComplexRadii(v);
-            v->codeAppend ("} break;");
+            v->codeAppend ("}");
         }
-        v->codeAppend("}");
     }
 
     this->adjustRRectVertices(v);
 
     if (fArcCoords.vsOut()) {
         v->codeAppendf("%s = (cornerSign * %s + radii - vec2(1)) / radii;",
                        fArcCoords.vsOut(), fModifiedShapeCoords);
     }
     if (fTriangleIsArc.vsOut()) {
         v->codeAppendf("%s = int(all(equal(vec2(1), abs(%s))));",
@@ skipping 57 matching lines @@
                                                     GrGLSLVertexBuilder* v) {
     SkASSERT(!(fBatchInfo.fInnerShapeTypes & (kNinePatch_ShapeFlag | kComplexRRect_ShapeFlag)));
 
     this->onInitInnerShape(varyingHandler, v);
 
     if (fInnerShapeCoords.vsOut()) {
         v->codeAppendf("%s = innerShapeCoords;", fInnerShapeCoords.vsOut());
     }
 }
 
-void GLSLInstanceProcessor::Backend::setupInnerRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::Backend::setupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
     v->codeAppend("mat2 innerP = ");
     fInputs.fetchNextParam(kMat22f_GrSLType);
     v->codeAppend(";");
     v->codeAppend("vec2 innerRadii = innerP[0] * 2.0 / innerP[1];");
-    this->onSetupInnerRRect(v);
+    this->onSetupInnerSimpleRRect(v);
 }
 
 void GLSLInstanceProcessor::Backend::emitCode(GrGLSLVertexBuilder* v, GrGLSLPPFragmentBuilder* f,
                                               const char* outCoverage, const char* outColor) {
     SkASSERT(!fModifiesCoverage || outCoverage);
     this->onEmitCode(v, f, fModifiesCoverage ? outCoverage : nullptr,
                      fModifiesColor ? outColor : nullptr);
     if (outCoverage && !fModifiesCoverage) {
         // Even though the subclass doesn't use coverage, we are expected to assign some value.
         f->codeAppendf("%s = vec4(1);", outCoverage);
@@ skipping 17 matching lines @@
     }
 
 private:
     void onInit(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupRect(GrGLSLVertexBuilder*) override;
     void setupOval(GrGLSLVertexBuilder*) override;
 
     void onInitInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupInnerRect(GrGLSLVertexBuilder*) override;
     void setupInnerOval(GrGLSLVertexBuilder*) override;
-    void onSetupInnerRRect(GrGLSLVertexBuilder*) override;
+    void onSetupInnerSimpleRRect(GrGLSLVertexBuilder*) override;
 
     void onEmitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*, const char*,
                     const char*) override;
 
     typedef Backend INHERITED;
 };
 
 void GLSLInstanceProcessor::BackendNonAA::onInit(GrGLSLVaryingHandler* varyingHandler,
                                                  GrGLSLVertexBuilder*) {
     if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
@@ skipping 29 matching lines @@
         v->codeAppendf("%s = vec4(1);", fInnerRRect.vsOut());
     }
 }
 
 void GLSLInstanceProcessor::BackendNonAA::setupInnerOval(GrGLSLVertexBuilder* v) {
     if (fInnerRRect.vsOut()) {
         v->codeAppendf("%s = vec4(0, 0, 1, 1);", fInnerRRect.vsOut());
     }
 }
 
-void GLSLInstanceProcessor::BackendNonAA::onSetupInnerRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::BackendNonAA::onSetupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
     v->codeAppendf("%s = vec4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
 }
 
 void GLSLInstanceProcessor::BackendNonAA::onEmitCode(GrGLSLVertexBuilder*,
                                                      GrGLSLPPFragmentBuilder* f,
                                                      const char* outCoverage,
                                                      const char* outColor) {
     const char* dropFragment = nullptr;
     if (!fBatchInfo.fCannotDiscard) {
         dropFragment = "discard";
@@ skipping 69 matching lines @@
 private:
     void onInit(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupRect(GrGLSLVertexBuilder*) override;
     void setupOval(GrGLSLVertexBuilder*) override;
     void adjustRRectVertices(GrGLSLVertexBuilder*) override;
     void onSetupRRect(GrGLSLVertexBuilder*) override;
 
     void onInitInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupInnerRect(GrGLSLVertexBuilder*) override;
     void setupInnerOval(GrGLSLVertexBuilder*) override;
-    void onSetupInnerRRect(GrGLSLVertexBuilder*) override;
+    void onSetupInnerSimpleRRect(GrGLSLVertexBuilder*) override;
 
     void onEmitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*, const char* outCoverage,
                     const char* outColor) override;
 
     void emitRect(GrGLSLPPFragmentBuilder*, const char* outCoverage, const char* outColor);
     void emitCircle(GrGLSLPPFragmentBuilder*, const char* outCoverage);
     void emitArc(GrGLSLPPFragmentBuilder* f, const char* ellipseCoords, const char* ellipseName,
                  bool ellipseCoordsNeedClamp, bool ellipseCoordsMayBeNegative,
                  const char* outCoverage);
     void emitInnerRect(GrGLSLPPFragmentBuilder*, const char* outCoverage);
@@ skipping 171 matching lines @@
     v->codeAppendf("%s = 1.0 / (innerShapeHalfSize * innerShapeHalfSize);",
                    fInnerEllipseName.vsOut());
     if (fInnerEllipseCoords.vsOut()) {
         v->codeAppendf("%s = innerShapeCoords * innerShapeHalfSize;", fInnerEllipseCoords.vsOut());
     }
     if (fInnerRRect.vsOut()) {
         v->codeAppendf("%s = vec4(0, 0, innerShapeHalfSize);", fInnerRRect.vsOut());
     }
 }
 
-void GLSLInstanceProcessor::BackendCoverage::onSetupInnerRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::BackendCoverage::onSetupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
     // The distance to ellipse formula doesn't work well when the radii are less than half a pixel.
     v->codeAppend ("innerRadii = max(innerRadii, bloat);");
     v->codeAppendf("%s = 1.0 / (innerRadii * innerRadii * innerShapeHalfSize * "
                                "innerShapeHalfSize);",
                    fInnerEllipseName.vsOut());
     v->codeAppendf("%s = vec4(1.0 - innerRadii, innerShapeHalfSize);", fInnerRRect.vsOut());
 }
 
 void GLSLInstanceProcessor::BackendCoverage::onEmitCode(GrGLSLVertexBuilder* v,
                                                         GrGLSLPPFragmentBuilder* f,
@@ skipping 161 matching lines @@
 
     void onInit(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupRect(GrGLSLVertexBuilder*) override;
     void setupOval(GrGLSLVertexBuilder*) override;
     void adjustRRectVertices(GrGLSLVertexBuilder*) override;
     void onSetupRRect(GrGLSLVertexBuilder*) override;
 
     void onInitInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*) override;
     void setupInnerRect(GrGLSLVertexBuilder*) override;
     void setupInnerOval(GrGLSLVertexBuilder*) override;
-    void onSetupInnerRRect(GrGLSLVertexBuilder*) override;
+    void onSetupInnerSimpleRRect(GrGLSLVertexBuilder*) override;
 
     void onEmitCode(GrGLSLVertexBuilder*, GrGLSLPPFragmentBuilder*, const char*,
                     const char*) override;
 
     struct EmitShapeCoords {
         const GrGLSLVarying*   fVarying;
         const char*            fInverseMatrix;
         const char*            fFragHalfSpan;
     };
 
@@ skipping 234 matching lines @@
                        fInnerRRect.vsOut());
     }
 }
 
 void GLSLInstanceProcessor::BackendMultisample::setupInnerOval(GrGLSLVertexBuilder* v) {
     if (fInnerRRect.vsOut()) {
         v->codeAppendf("%s = vec4(0, 0, 1, 1);", fInnerRRect.vsOut());
     }
 }
 
-void GLSLInstanceProcessor::BackendMultisample::onSetupInnerRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::BackendMultisample::onSetupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
     // Avoid numeric instability by not allowing the inner radii to get smaller than 1/10th pixel.
     if (fFragInnerShapeHalfSpan.vsOut()) {
         v->codeAppendf("innerRadii = max(innerRadii, 2e-1 * %s);", fFragInnerShapeHalfSpan.vsOut());
     } else {
         v->codeAppend ("innerRadii = max(innerRadii, vec2(1e-4));");
     }
     v->codeAppendf("%s = vec4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
 }
 
 void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
@@ skipping 754 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";
     }
 }
 
 }