Distance field fixes for Android

src/gpu/effects/GrDistanceFieldTextureEffect.cpp

Index: src/gpu/effects/GrDistanceFieldTextureEffect.cpp
diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
index 9159a701e32a966bbb0ba1a3d465b35cd3abc6d2..c8d61ffafd04ef063a12b3f3d290c651fbc25d5b 100755
--- a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
+++ b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
@@ -35,6 +35,8 @@ public:
         SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
 
         SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
+        const GrDistanceFieldTextureEffect& dfTexEffect =
+                                              drawEffect.castEffect<GrDistanceFieldTextureEffect>();
 
         SkString fsCoordName;
         const char* vsCoordName;
@@ -61,16 +63,37 @@ public:
         // we adjust for the effect of the transformation on the distance by using
         // the length of the gradient of the texture coordinates. We use st coordinates
         // to ensure we're mapping 1:1 from texel space to pixel space.
-        builder->fsCodeAppendf("\tvec2 st = %s*%s;\n", fsCoordName.c_str(), textureSizeUniName);
-        builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
-        builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
-        builder->fsCodeAppend("\tvec2 st_grad = normalize(st);\n");
-        builder->fsCodeAppend("\tvec2 grad = vec2(st_grad.x*Jdx.x + st_grad.y*Jdy.x,\n");
-        builder->fsCodeAppend("\t                 st_grad.x*Jdx.y + st_grad.y*Jdy.y);\n");
-
-        // this gives us a smooth step across approximately one fragment
-        // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
-        builder->fsCodeAppend("\tfloat afwidth = 0.7071*length(grad);\n");
+        builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
+        builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
+        builder->fsCodeAppend("\tfloat afwidth;\n");
+        if (dfTexEffect.isUniformScale()) {
+            // this gives us a smooth step across approximately one fragment
+            // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+            builder->fsCodeAppend("\tafwidth = 0.7071*dFdx(st.x);\n");
+        } else {
+            builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
+            builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
+
+            builder->fsCodeAppend("\tvec2 uv_grad;\n");
+#ifdef SK_BUILD_FOR_ANDROID

[bsalomon, 2014/03/26 13:18:58]

Can we make this a runtime check based on Vendor or Renderer? Branches are
really expensive on some of the mobile GPUs and we shouldn't pay the penalty on
all devices if we don't have to.

Actually, I think we should capture the drops-tile-on-divide-by-zero in GrGLCaps
and query that here. It has come up before and likely will come up again. If we
ever refine the detection mechanism then all effects that care will benefit.

[jvanverth1, 2014/03/26 16:24:00]

Done.

+            // this is to compensate for the Adreno, which likes to drop tiles on division by 0
+            builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
+            builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
+            builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
+            builder->fsCodeAppend("\t} else {\n");
+            builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
+            builder->fsCodeAppend("\t}\n");
+#else
+            builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
+#endif
+            builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
+            builder->fsCodeAppend("\t                 uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
+
+            // this gives us a smooth step across approximately one fragment
+            // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+            builder->fsCodeAppend("\tafwidth = 0.7071*length(grad);\n");
+        }
+
         builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
 
         builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
@@ -102,9 +125,11 @@ private:
 
 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
                                                            const GrTextureParams& params,
-                                                           const SkISize& size)
+                                                           const SkISize& size,
+                                                           bool uniformScale)
     : fTextureAccess(texture, params)
-    , fSize(SkSize::Make(SkIntToScalar(size.width()), SkIntToScalar(size.height()))) {
+    , fSize(SkSize::Make(SkIntToScalar(size.width()), SkIntToScalar(size.height())))
+    , fUniformScale(uniformScale) {
     this->addTextureAccess(&fTextureAccess);
     this->addVertexAttrib(kVec2f_GrSLType);
 }
@@ -151,5 +176,5 @@ GrEffectRef* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
                                                            GrTextureParams::kNone_FilterMode);
     SkISize size = SkISize::Make(1024, 2048);
 
-    return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, size);
+    return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, size, random->nextBool());
 }