Real fix for the Mali bug.

src/gpu/effects/GrDistanceFieldGeoProc.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 "GrDistanceFieldGeoProc.h"
 #include "GrFontAtlasSizes.h"
 #include "GrInvariantOutput.h"
@@ skipping 58 matching lines @@
 
         // emit transforms
         const SkMatrix& localMatrix = dfTexEffect.localMatrix();
         this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosition()->fName,
                              localMatrix, args.fTransformsIn, args.fTransformsOut);
 
         // add varyings
         GrGLVertToFrag recipScale(kFloat_GrSLType);
         GrGLVertToFrag st(kVec2f_GrSLType);
         bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
-        const char* viewMatrixName = this->uViewM();
-        // view matrix name is NULL if identity matrix
-        bool useInverseScale = !localMatrix.isIdentity() && viewMatrixName;
-        if (isSimilarity && useInverseScale) {
-            args.fPB->addVarying("RecipScale", &recipScale, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("vec2 tx = vec2(%s[0][0], %s[1][0]);",
-                                   viewMatrixName, viewMatrixName);
-            vsBuilder->codeAppend("float tx2 = dot(tx, tx);");
-            vsBuilder->codeAppendf("%s = inversesqrt(tx2);", recipScale.vsOut());
-        } else {
-            args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName);
-        }
+        args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
+        vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
         GrGLVertToFrag uv(kVec2f_GrSLType);
         args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
         // this is only used with text, so our texture bounds always match the glyph atlas
         vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", "
                                GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(),
                                dfTexEffect.inTextureCoords()->fName);
         
         // Use highp to work around aliasing issues
         fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision,
                                                              pb->ctxInfo().standard()));
         fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
 
         fsBuilder->codeAppend("\tfloat texColor = ");
         fsBuilder->appendTextureLookup(args.fSamplers[0],
                                        "uv",
                                        kVec2f_GrSLType);
         fsBuilder->codeAppend(".r;\n");
         fsBuilder->codeAppend("\tfloat distance = "
                        SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
 #ifdef SK_GAMMA_APPLY_TO_A8
         // adjust width based on gamma
         fsBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName);
 #endif
 
         fsBuilder->codeAppend("float afwidth;");
         if (isSimilarity) {
             // For uniform scale, we adjust for the effect of the transformation on the distance
-            // either by using the inverse scale in the view matrix, or (if there is no view matrix)
             // by using the length of the gradient of the texture coordinates. We use st coordinates
-            // with the latter to ensure we're mapping 1:1 from texel space to pixel space.
+            // to ensure we're mapping 1:1 from texel space to pixel space.
 
             // this gives us a smooth step across approximately one fragment
-            if (useInverseScale) {
-                fsBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor "*%s);",
-                                       recipScale.fsIn());
-            } else {
-                fsBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdx(%s.x));",
+            // we use y to work around a Mali400 bug in the x direction
+            fsBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdy(%s.y));",
                                        st.fsIn());
-            }
         } else {
             // For general transforms, to determine the amount of correction we multiply a unit
             // vector pointing along the SDF gradient direction by the Jacobian of the st coords
             // (which is the inverse transform for this fragment) and take the length of the result.
             fsBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance), dFdy(distance));");
             // the length of the gradient may be 0, so we need to check for this
             // this also compensates for the Adreno, which likes to drop tiles on division by 0
             fsBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);");
             fsBuilder->codeAppend("if (dg_len2 < 0.0001) {");
             fsBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);");
@@ skipping 40 matching lines @@
     static inline void GenKey(const GrGeometryProcessor& gp,
                               const GrBatchTracker& bt,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldA8TextGeoProc& dfTexEffect = gp.cast<GrDistanceFieldA8TextGeoProc>();
         const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>();
         uint32_t key = dfTexEffect.getFlags();
         key |= local.fInputColorType << 16;
         key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24: 0x0;
         key |= ComputePosKey(gp.viewMatrix()) << 25;
-        key |= (!gp.viewMatrix().isIdentity() && !gp.localMatrix().isIdentity()) ? 0x1 << 27 : 0x0;
         b->add32(key);
     }
 
 private:
     GrColor       fColor;
     UniformHandle fColorUniform;
 #ifdef SK_GAMMA_APPLY_TO_A8
     float         fDistanceAdjust;
     UniformHandle fDistanceAdjustUni;
 #endif
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(GrColor color,
                                                            const SkMatrix& viewMatrix,
-                                                           const SkMatrix& localMatrix,
                                                            GrTexture* texture,
                                                            const GrTextureParams& params,
 #ifdef SK_GAMMA_APPLY_TO_A8
                                                            float distanceAdjust,
 #endif
                                                            uint32_t flags, bool opaqueVertexColors)
-    : INHERITED(color, viewMatrix, localMatrix, opaqueVertexColors)
+    : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors)
     , fTextureAccess(texture, params)
 #ifdef SK_GAMMA_APPLY_TO_A8
     , fDistanceAdjust(distanceAdjust)
 #endif
     , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
     , fInColor(NULL) {
     SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
     this->initClassID<GrDistanceFieldA8TextGeoProc>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     if (flags & kColorAttr_DistanceFieldEffectFlag) {
@@ skipping 66 matching lines @@
     };
     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);
 
     return GrDistanceFieldA8TextGeoProc::Create(GrRandomColor(random),
                                                 GrProcessorUnitTest::TestMatrix(random),
-                                                GrProcessorUnitTest::TestMatrix(random),
                                                 textures[texIdx], params,
 #ifdef SK_GAMMA_APPLY_TO_A8
                                                 random->nextF(),
 #endif
                                                 random->nextBool() ?
                                                     kSimilarity_DistanceFieldEffectFlag : 0,
                                                 random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 272 matching lines @@
 
         // emit transforms
         const SkMatrix& localMatrix = dfTexEffect.localMatrix();
         this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosition()->fName,
                              localMatrix, args.fTransformsIn, args.fTransformsOut);
 
         // set up varyings
         bool isUniformScale = SkToBool(dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask);
         GrGLVertToFrag recipScale(kFloat_GrSLType);
         GrGLVertToFrag st(kVec2f_GrSLType);
-        const char* viewMatrixName = this->uViewM();
-        // view matrix name is NULL if identity matrix
-        bool useInverseScale = !localMatrix.isIdentity() && viewMatrixName;
-        if (isUniformScale && useInverseScale) {
-            args.fPB->addVarying("RecipScale", &recipScale, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("vec2 tx = vec2(%s[0][0], %s[1][0]);",
-                                   viewMatrixName, viewMatrixName);
-            vsBuilder->codeAppend("float tx2 = dot(tx, tx);");
-            vsBuilder->codeAppendf("%s = inversesqrt(tx2);", recipScale.vsOut());
-        } else {
-            args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
-            vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName);
-        }
+        args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
+        vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
         GrGLVertToFrag uv(kVec2f_GrSLType);
         args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
         // this is only used with text, so our texture bounds always match the glyph atlas
         vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", "
                                GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(),
                                dfTexEffect.inTextureCoords()->fName);
 
         // add frag shader code
         GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
         SkAssertResult(fsBuilder->enableFeature(
                 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
 
         // create LCD offset adjusted by inverse of transform
         // Use highp to work around aliasing issues
         fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision,
                                                              pb->ctxInfo().standard()));
         fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
         fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision,
                                                              pb->ctxInfo().standard()));
         if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
             fsBuilder->codeAppend("float delta = -" GR_FONT_ATLAS_LCD_DELTA ";\n");
         } else {
             fsBuilder->codeAppend("float delta = " GR_FONT_ATLAS_LCD_DELTA ";\n");
         }
         if (isUniformScale) {
-            if (useInverseScale) {
-                fsBuilder->codeAppendf("float dx = %s;", recipScale.fsIn());
-            } else {
-                fsBuilder->codeAppendf("float dx = dFdx(%s.x);", st.fsIn());
-            }
-            fsBuilder->codeAppend("vec2 offset = vec2(dx*delta, 0.0);");
+            fsBuilder->codeAppendf("float dy = dFdy(%s.y);", st.fsIn());
+            fsBuilder->codeAppend("vec2 offset = vec2(dy*delta, 0.0);");
         } else {
             fsBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn());
 
             fsBuilder->codeAppend("vec2 Jdx = dFdx(st);");
             fsBuilder->codeAppend("vec2 Jdy = dFdy(st);");
             fsBuilder->codeAppend("vec2 offset = delta*Jdx;");
         }
 
         // green is distance to uv center
         fsBuilder->codeAppend("\tvec4 texColor = ");
@@ skipping 28 matching lines @@
         // for each color component. However, this is only important when using perspective
         // transformations, and even then using a single factor seems like a reasonable
         // trade-off between quality and speed.
         fsBuilder->codeAppend("float afwidth;");
         if (isUniformScale) {
             // For uniform scale, 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.
 
             // this gives us a smooth step across approximately one fragment
-            fsBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dx);");
+            fsBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dy);");
         } else {
             // For general transforms, to determine the amount of correction we multiply a unit
             // vector pointing along the SDF gradient direction by the Jacobian of the st coords
             // (which is the inverse transform for this fragment) and take the length of the result.
             fsBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance.r), dFdy(distance.r));");
             // the length of the gradient may be 0, so we need to check for this
             // this also compensates for the Adreno, which likes to drop tiles on division by 0
             fsBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);");
             fsBuilder->codeAppend("if (dg_len2 < 0.0001) {");
             fsBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);");
@@ skipping 44 matching lines @@
                               const GrBatchTracker& bt,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldLCDTextGeoProc& dfTexEffect = gp.cast<GrDistanceFieldLCDTextGeoProc>();
 
         const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatchTracker>();
         uint32_t key = dfTexEffect.getFlags();
         key |= local.fInputColorType << 16;
         key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24: 0x0;
         key |= ComputePosKey(gp.viewMatrix()) << 25;
-        key |= (!gp.viewMatrix().isIdentity() && !gp.localMatrix().isIdentity()) ? 0x1 << 27 : 0x0;
         b->add32(key);
     }
 
 private:
     GrColor                                      fColor;
     UniformHandle                                fColorUniform;
     GrDistanceFieldLCDTextGeoProc::DistanceAdjust fDistanceAdjust;
     UniformHandle                                fDistanceAdjustUni;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(
                                                   GrColor color, const SkMatrix& viewMatrix,
-                                                  const SkMatrix& localMatrix,
                                                   GrTexture* texture, const GrTextureParams& params,
                                                   DistanceAdjust distanceAdjust,
                                                   uint32_t flags)
-    : INHERITED(color, viewMatrix, localMatrix)
+    : INHERITED(color, viewMatrix, SkMatrix::I())
     , fTextureAccess(texture, params)
     , fDistanceAdjust(distanceAdjust)
     , fFlags(flags & kLCD_DistanceFieldEffectMask){
     SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
     this->initClassID<GrDistanceFieldLCDTextGeoProc>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                           kVec2s_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
@@ skipping 59 matching lines @@
         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
     };
     GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
                            GrTextureParams::kNone_FilterMode);
     DistanceAdjust wa = { 0.0f, 0.1f, -0.1f };
     uint32_t flags = kUseLCD_DistanceFieldEffectFlag;
     flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0;
     flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0;
     return GrDistanceFieldLCDTextGeoProc::Create(GrRandomColor(random),
                                                  GrProcessorUnitTest::TestMatrix(random),
-                                                 GrProcessorUnitTest::TestMatrix(random),
                                                  textures[texIdx], params,
                                                  wa,
                                                  flags);
 }