Distance field fixes for Android

src/gpu/effects/GrDistanceFieldTextureEffect.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 "GrDistanceFieldTextureEffect.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
@@ skipping 17 matching lines @@
     virtual void emitCode(GrGLFullShaderBuilder* builder,
                           const GrDrawEffect& drawEffect,
                           EffectKey key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray& samplers) SK_OVERRIDE {
         SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
 
         SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
+        const GrDistanceFieldTextureEffect& dfTexEffect =
+                                              drawEffect.castEffect<GrDistanceFieldTextureEffect>();
 
         SkString fsCoordName;
         const char* vsCoordName;
         const char* fsCoordNamePtr;
         builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
         fsCoordName = fsCoordNamePtr;
 
         const char* attrName0 =
             builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
         builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
 
         const char* textureSizeUniName = NULL;
         fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                               kVec2f_GrSLType, "TextureSize",
                                               &textureSizeUniName);
 
         builder->fsCodeAppend("\tvec4 texColor = ");
         builder->fsAppendTextureLookup(samplers[0],
                                        fsCoordName.c_str(),
                                        kVec2f_GrSLType);
         builder->fsCodeAppend(";\n");
         builder->fsCodeAppend("\tfloat distance = " MULTIPLIER "*(texColor.r - " THRESHOLD ");\n");
 
         // 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");
+        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");
 
-        // 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->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,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
     }
 
     virtual void setData(const GrGLUniformManager& uman,
                          const GrDrawEffect& drawEffect) SK_OVERRIDE {
         SkASSERT(fTextureSizeUni.isValid());
         const GrDistanceFieldTextureEffect& distanceFieldEffect =
@@ skipping 11 matching lines @@
     GrGLUniformManager::UniformHandle fTextureSizeUni;
     SkSize                            fTextureSize;
 
     typedef GrGLVertexEffect INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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);
 }
 
 bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
     const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
     return fTextureAccess == cte.fTextureAccess;
 }
 
 void GrDistanceFieldTextureEffect::getConstantColorComponents(GrColor* color,
@@ skipping 26 matching lines @@
         SkShader::kMirror_TileMode,
     };
     SkShader::TileMode tileModes[] = {
         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
     };
     GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
                                                            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());
 }