Add effect caching to distance field text.

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/GrGLShaderBuilder.h"
@@ skipping 61 matching lines @@
         builder->fsCodeAppend("\tfloat distance = "
                           SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ")"
                           "+ " SK_DistanceFieldNonLCDFactor ";\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 uv = %s;\n", fsCoordName.c_str());
         builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
         builder->fsCodeAppend("\tfloat afwidth;\n");
-        if (dfTexEffect.isSimilarity()) {
+        if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) {
             // this gives us a smooth step across approximately one fragment
             builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*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");
             if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
                 // 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");
@@ skipping 53 matching lines @@
             fLuminance = luminance;
         }
 #endif
     }
 
     static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
                               GrEffectKeyBuilder* b) {
         const GrDistanceFieldTextureEffect& dfTexEffect =
                                               drawEffect.castEffect<GrDistanceFieldTextureEffect>();
 
-        b->add32(dfTexEffect.isSimilarity());
+        b->add32(dfTexEffect.getFlags());
     }
 
 private:
     GrGLProgramDataManager::UniformHandle fTextureSizeUni;
     SkISize                               fTextureSize;
     GrGLProgramDataManager::UniformHandle fLuminanceUni;
     float                                 fLuminance;
 
     typedef GrGLVertexEffect INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
                                                            const GrTextureParams& params,
 #ifdef SK_GAMMA_APPLY_TO_A8
                                                            GrTexture* gamma,
                                                            const GrTextureParams& gammaParams,
                                                            float luminance,
 #endif
-                                                           bool similarity)
+                                                           uint32_t flags)
     : fTextureAccess(texture, params)
 #ifdef SK_GAMMA_APPLY_TO_A8
     , fGammaTextureAccess(gamma, gammaParams)
     , fLuminance(luminance)
 #endif
-    , fIsSimilarity(similarity) {
+    , fFlags(flags & kNonLCD_DistanceFieldEffectMask) {
+    SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
     this->addTextureAccess(&fTextureAccess);
 #ifdef SK_GAMMA_APPLY_TO_A8
     this->addTextureAccess(&fGammaTextureAccess);
 #endif
     this->addVertexAttrib(kVec2f_GrSLType);
 }
 
 bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
     const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
-    return fTextureAccess == cte.fTextureAccess;
+    return fTextureAccess == cte.fTextureAccess &&
+#ifdef SK_GAMMA_APPLY_TO_A8
+           fGammaTextureAccess == cte.fGammaTextureAccess &&
+           fLuminance == cte.fLuminance &&
+#endif
+           fFlags == cte.fFlags;
 }
 
 void GrDistanceFieldTextureEffect::getConstantColorComponents(GrColor* color,
                                                              uint32_t* validFlags) const {
     if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
         GrPixelConfigIsOpaque(this->texture(0)->config())) {
         *validFlags = kA_GrColorComponentFlag;
     } else {
         *validFlags = 0;
     }
@@ skipping 31 matching lines @@
 #ifdef SK_GAMMA_APPLY_TO_A8
     GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
                                                             GrTextureParams::kNone_FilterMode);
 #endif
 
     return GrDistanceFieldTextureEffect::Create(textures[texIdx], params,
 #ifdef SK_GAMMA_APPLY_TO_A8
                                                 textures[texIdx2], params2,
                                                 random->nextF(),
 #endif
-                                                random->nextBool());
+                                                random->nextBool() ?
+                                                    kSimilarity_DistanceFieldEffectFlag : 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistanceFieldLCDTextureEffect : public GrGLVertexEffect {
 public:
     GrGLDistanceFieldLCDTextureEffect(const GrBackendEffectFactory& factory,
                                       const GrDrawEffect& drawEffect)
     : INHERITED (factory)
     , fTextureSize(SkISize::Make(-1,-1)) {}
@@ skipping 23 matching lines @@
 
         const char* textureSizeUniName = NULL;
         // width, height, 1/(3*width)
         fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                               kVec3f_GrSLType, "TextureSize",
                                               &textureSizeUniName);
 
         // create LCD offset adjusted by inverse of transform
         builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
         builder->fsCodeAppendf("\tvec2 st = uv*%s.xy;\n", textureSizeUniName);
-        if (dfTexEffect.isUniformScale()) {
+        bool isUniformScale = !!(dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask);
+        if (isUniformScale) {
             builder->fsCodeAppend("\tfloat dx = dFdx(st.x);\n");
             builder->fsCodeAppendf("\tvec2 offset = vec2(dx*%s.z, 0.0);\n", textureSizeUniName);
         } else {
             builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
             builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
             builder->fsCodeAppendf("\tvec2 offset = %s.z*Jdx;\n", textureSizeUniName);
         }
 
         // green is distance to uv center
         builder->fsCodeAppend("\tvec4 texColor = ");
@@ skipping 20 matching lines @@
 
         // 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.
 
         // To be strictly correct, we should compute the anti-aliasing factor separately
         // 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.
         builder->fsCodeAppend("\tfloat afwidth;\n");
-        if (dfTexEffect.isUniformScale()) {
+        if (isUniformScale) {
             // this gives us a smooth step across approximately one fragment
             builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dx;\n");
         } else {
             builder->fsCodeAppend("\tvec2 uv_grad;\n");
             if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
                 // 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");
@@ skipping 45 matching lines @@
         SkASSERT(fTextureSizeUni.isValid());
         SkASSERT(fTextColorUni.isValid());
 
         const GrDistanceFieldLCDTextureEffect& dfTexEffect =
                                     drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
         GrTexture* texture = drawEffect.effect()->texture(0);
         if (texture->width() != fTextureSize.width() ||
             texture->height() != fTextureSize.height()) {
             fTextureSize = SkISize::Make(texture->width(), texture->height());
             float delta = 1.0f/(3.0f*texture->width());
-            if (dfTexEffect.useBGR()) {
+            if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
                 delta = -delta;
             }
             pdman.set3f(fTextureSizeUni,
                         SkIntToScalar(fTextureSize.width()),
                         SkIntToScalar(fTextureSize.height()),
                         delta);
         }
 
         GrColor textColor = dfTexEffect.getTextColor();
         if (textColor != fTextColor) {
             static const float ONE_OVER_255 = 1.f / 255.f;
             pdman.set3f(fTextColorUni,
                         GrColorUnpackR(textColor) * ONE_OVER_255,
                         GrColorUnpackG(textColor) * ONE_OVER_255,
                         GrColorUnpackB(textColor) * ONE_OVER_255);
             fTextColor = textColor;
         }
     }
 
     static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
                               GrEffectKeyBuilder* b) {
         const GrDistanceFieldLCDTextureEffect& dfTexEffect =
                                            drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
 
-        b->add32(dfTexEffect.isUniformScale());
+        b->add32(dfTexEffect.getFlags());
     }
 
 private:
     GrGLProgramDataManager::UniformHandle fTextureSizeUni;
     SkISize                               fTextureSize;
     GrGLProgramDataManager::UniformHandle fTextColorUni;
     SkColor                               fTextColor;
 
     typedef GrGLVertexEffect INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(
                                                   GrTexture* texture, const GrTextureParams& params,
                                                   GrTexture* gamma, const GrTextureParams& gParams,
                                                   SkColor textColor,
-                                                  bool uniformScale, bool useBGR)
+                                                  uint32_t flags)
     : fTextureAccess(texture, params)
     , fGammaTextureAccess(gamma, gParams)
     , fTextColor(textColor)
-    , fUniformScale(uniformScale)
-    , fUseBGR(useBGR) {
+    , fFlags(flags & kLCD_DistanceFieldEffectMask) {
+    SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
+        
     this->addTextureAccess(&fTextureAccess);
     this->addTextureAccess(&fGammaTextureAccess);
     this->addVertexAttrib(kVec2f_GrSLType);
 }
 
 bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const {
     const GrDistanceFieldLCDTextureEffect& cte = 
                                             CastEffect<GrDistanceFieldLCDTextureEffect>(other);
-    return (fTextureAccess == cte.fTextureAccess && fGammaTextureAccess == cte.fGammaTextureAccess);
+    return (fTextureAccess == cte.fTextureAccess &&
+            fGammaTextureAccess == cte.fGammaTextureAccess &&
+            fTextColor == cte.fTextColor &&
+            fFlags == cte.fFlags);
 }
 
 void GrDistanceFieldLCDTextureEffect::getConstantColorComponents(GrColor* color,
                                                                  uint32_t* validFlags) const {
     if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
         GrPixelConfigIsOpaque(this->texture(0)->config())) {
         *validFlags = kA_GrColorComponentFlag;
     } else {
         *validFlags = 0;
     }
@@ skipping 25 matching lines @@
         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
     };
     GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
                            GrTextureParams::kNone_FilterMode);
     GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
                            GrTextureParams::kNone_FilterMode);
     GrColor textColor = GrColorPackRGBA(random->nextULessThan(256),
                                         random->nextULessThan(256),
                                         random->nextULessThan(256),
                                         random->nextULessThan(256));
+    uint32_t flags = kUseLCD_DistanceFieldEffectFlag;
+    flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0;
+    flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0;
     return GrDistanceFieldLCDTextureEffect::Create(textures[texIdx], params,
                                                    textures[texIdx2], params2,
                                                    textColor,
-                                                   random->nextBool(), random->nextBool());
+                                                   flags);
 }