Fix stroked roundrects on Nexus 10

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrEffect.h"
@@ skipping 269 matching lines @@
                                            GrContext* context,
                                            const GrDrawTargetCaps&,
                                            GrTexture* textures[]) {
     return EllipseEdgeEffect::Create(random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for an axis-aligned
- * ellipse, specified as an offset vector from center and outer and inner radii in both
- * x and y directions.
+ * ellipse, specified as an offset vector from center and reciprocals of outer and inner radii in 
+ * both x and y directions.
  *
  * This uses a slightly different algorithm than the EllipseEdgeEffect, above. Rather than
  * scaling an ellipse to be a circle, it attempts to find the distance from the offset point to the
  * ellipse by determining where the line through the origin and offset point would cross the
  * ellipse, and computing the distance to that. This is slower but works better for roundrects
  * because the straight edges will be more accurate.
  */
 
 class AltEllipseEdgeEffect : public GrEffect {
 public:
@@ skipping 48 matching lines @@
             builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName, attr0Name->c_str());
 
             builder->addVarying(kVec4f_GrSLType, "EllipseRadii", &vsRadiiName, &fsRadiiName);
             const SkString* attr1Name =
                 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[1]);
             builder->vsCodeAppendf("\t%s = %s;\n", vsRadiiName, attr1Name->c_str());
 
             builder->fsCodeAppend("\tfloat edgeAlpha;\n");
             // get length of offset
             builder->fsCodeAppendf("\tfloat len = length(%s.xy);\n", fsOffsetName);
-            builder->fsCodeAppend("\tvec2 offset;\n");
 
             // for outer curve
-            builder->fsCodeAppendf("\toffset.xy = %s.xy*%s.yx;\n",
+            builder->fsCodeAppendf("\tvec2 offset = %s.xy*%s.xy;\n",
                                    fsOffsetName, fsRadiiName);
-            builder->fsCodeAppendf("\tfloat tOuter = "
-                                   "%s.x*%s.y*inversesqrt(dot(offset.xy, offset.xy));\n",
-                                   fsRadiiName, fsRadiiName);
-            builder->fsCodeAppend("\tedgeAlpha = clamp(len*tOuter - len, 0.0, 1.0);\n");
+            builder->fsCodeAppendf("\tfloat t = inversesqrt(dot(offset.xy, offset.xy));\n");
+            builder->fsCodeAppend("\tedgeAlpha = clamp(len*t - len, 0.0, 1.0);\n");
 
             // for inner curve
             if (rrectEffect.isStroked()) {
-                builder->fsCodeAppendf("\toffset.xy = %s.xy*%s.wz;\n",
+                builder->fsCodeAppendf("\toffset = %s.xy*%s.zw;\n",
                                        fsOffsetName, fsRadiiName);
-                builder->fsCodeAppendf("\tfloat tInner = "
-                                       "%s.z*%s.w*inversesqrt(dot(offset.xy, offset.xy));\n",
-                                       fsRadiiName, fsRadiiName);
-                builder->fsCodeAppend("\tedgeAlpha *= clamp(len - len*tInner, 0.0, 1.0);\n");
+                builder->fsCodeAppendf("\tt = inversesqrt(dot(offset.xy, offset.xy));\n");
+                builder->fsCodeAppend("\tedgeAlpha *= clamp(len - len*t, 0.0, 1.0);\n");
             }
 
             SkString modulate;
             GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
             builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
         }
 
         static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
             const AltEllipseEdgeEffect& rrectEffect = drawEffect.castEffect<AltEllipseEdgeEffect>();
 
@@ skipping 564 matching lines @@
             bounds.fBottom - yOuterRadius,
             bounds.fBottom
         };
         SkScalar yOuterOffsets[4] = {
             -yOuterRadius,
             SK_ScalarNearlyZero, // we're using inversesqrt() in the shader, so can't be exactly 0
             SK_ScalarNearlyZero,
             yOuterRadius
         };
 
+        SkScalar recipOuterX = SK_Scalar1/xOuterRadius;
+        SkScalar recipOuterY = SK_Scalar1/yOuterRadius;
+        SkScalar recipInnerX = SK_Scalar1/xInnerRadius;
+        SkScalar recipInnerY = SK_Scalar1/yInnerRadius;
+        
         for (int i = 0; i < 4; ++i) {
             verts->fPos = SkPoint::Make(bounds.fLeft, yCoords[i]);
             verts->fOffset = SkPoint::Make(-xOuterRadius, yOuterOffsets[i]);
-            verts->fOuterRadii = SkPoint::Make(xOuterRadius, yOuterRadius);
-            verts->fInnerRadii = SkPoint::Make(xInnerRadius, yInnerRadius);
+            verts->fOuterRadii = SkPoint::Make(recipOuterX, recipOuterY);
+            verts->fInnerRadii = SkPoint::Make(recipInnerX, recipInnerY);
             verts++;
 
             verts->fPos = SkPoint::Make(bounds.fLeft + xOuterRadius, yCoords[i]);
             verts->fOffset = SkPoint::Make(SK_ScalarNearlyZero, yOuterOffsets[i]);
-            verts->fOuterRadii = SkPoint::Make(xOuterRadius, yOuterRadius);
-            verts->fInnerRadii = SkPoint::Make(xInnerRadius, yInnerRadius);
+            verts->fOuterRadii = SkPoint::Make(recipOuterX, recipOuterY);
+            verts->fInnerRadii = SkPoint::Make(recipInnerX, recipInnerY);
             verts++;
 
             verts->fPos = SkPoint::Make(bounds.fRight - xOuterRadius, yCoords[i]);
             verts->fOffset = SkPoint::Make(SK_ScalarNearlyZero, yOuterOffsets[i]);
-            verts->fOuterRadii = SkPoint::Make(xOuterRadius, yOuterRadius);
-            verts->fInnerRadii = SkPoint::Make(xInnerRadius, yInnerRadius);
+            verts->fOuterRadii = SkPoint::Make(recipOuterX, recipOuterY);
+            verts->fInnerRadii = SkPoint::Make(recipInnerX, recipInnerY);
             verts++;
 
             verts->fPos = SkPoint::Make(bounds.fRight, yCoords[i]);
             verts->fOffset = SkPoint::Make(xOuterRadius, yOuterOffsets[i]);
-            verts->fOuterRadii = SkPoint::Make(xOuterRadius, yOuterRadius);
-            verts->fInnerRadii = SkPoint::Make(xInnerRadius, yInnerRadius);
+            verts->fOuterRadii = SkPoint::Make(recipOuterX, recipOuterY);
+            verts->fInnerRadii = SkPoint::Make(recipInnerX, recipInnerY);
             verts++;
         }
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStroked ? GR_ARRAY_COUNT(gRRectIndices)-6 : GR_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds);
     }
 
     return true;
 }