Draft change to start pulling uniform color into GP

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 "GrInvariantOutput.h"
 #include "GrTexture.h"
 #include "SkDistanceFieldGen.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 // Assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2
 #define SK_DistanceFieldAAFactor     "0.7071"
 
+struct DistanceFieldBatchTracker {
+    GrGPInput fInputColorType;
+    GrColor fColor;
+};
+
 class GrGLDistanceFieldTextureEffect : public GrGLGeometryProcessor {
 public:
     GrGLDistanceFieldTextureEffect(const GrGeometryProcessor&,
                                    const GrBatchTracker&)
-        : fTextureSize(SkISize::Make(-1,-1))
+        : fColor(GrColor_ILLEGAL)
+        , fTextureSize(SkISize::Make(-1,-1))
 #ifdef SK_GAMMA_APPLY_TO_A8
         , fLuminance(-1.0f)
 #endif
         {}
 
     virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
         const GrDistanceFieldTextureEffect& dfTexEffect =
                 args.fGP.cast<GrDistanceFieldTextureEffect>();
-
+        const DistanceFieldBatchTracker& local = args.fBT.cast<DistanceFieldBatchTracker>();
+        GrGLGPBuilder* pb = args.fPB;
         GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         SkAssertResult(fsBuilder->enableFeature(
                 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
 
         GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
         GrGLVertToFrag v(kVec2f_GrSLType);
         args.fPB->addVarying("TextureCoords", &v);
         vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
-        // setup color attribute
-        if(dfTexEffect.inColor()) {
-            args.fPB->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
-        }
+        // Setup pass through color
+        this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor,
+                                    dfTexEffect.inColor(), &fColorUniform);
 
         // setup position varying
         vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(),
                                vsBuilder->uViewM(), dfTexEffect.inPosition()->fName);
 
         // setup output coords
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(),
                                dfTexEffect.inPosition()->fName);
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(),
                                dfTexEffect.inPosition()->fName);
@@ skipping 56 matching lines @@
         fsBuilder->codeAppend("\tvec4 gammaColor = ");
         fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType);
         fsBuilder->codeAppend(";\n");
         fsBuilder->codeAppend("\tval = gammaColor.r;\n");
 #endif
 
         fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage);
     }
 
     virtual void setData(const GrGLProgramDataManager& pdman,
-                         const GrGeometryProcessor& proc,
-                         const GrBatchTracker&) SK_OVERRIDE {
+                         const GrPrimitiveProcessor& proc,
+                         const GrBatchTracker& bt) SK_OVERRIDE {
         SkASSERT(fTextureSizeUni.isValid());
 
         GrTexture* texture = proc.texture(0);
         if (texture->width() != fTextureSize.width() ||
             texture->height() != fTextureSize.height()) {
             fTextureSize = SkISize::Make(texture->width(), texture->height());
             pdman.set2f(fTextureSizeUni,
                         SkIntToScalar(fTextureSize.width()),
                         SkIntToScalar(fTextureSize.height()));
         }
 #ifdef SK_GAMMA_APPLY_TO_A8
         const GrDistanceFieldTextureEffect& dfTexEffect =
                 proc.cast<GrDistanceFieldTextureEffect>();
         float luminance = dfTexEffect.getLuminance();
         if (luminance != fLuminance) {
             pdman.set1f(fLuminanceUni, luminance);
             fLuminance = luminance;
         }
 #endif
+
+        const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>();
+        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
+            GrGLfloat c[4];
+            GrColorToRGBAFloat(local.fColor, c);
+            pdman.set4fv(fColorUniform, 1, c);
+            fColor = local.fColor;
+        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& processor,
-                              const GrBatchTracker&,
+                              const GrBatchTracker& bt,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldTextureEffect& dfTexEffect =
                 processor.cast<GrDistanceFieldTextureEffect>();
-
+        const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>();
         b->add32(dfTexEffect.getFlags());
+        b->add32(local.fInputColorType);
     }
 
 private:
-    GrGLProgramDataManager::UniformHandle fTextureSizeUni;
-    SkISize                               fTextureSize;
-    GrGLProgramDataManager::UniformHandle fLuminanceUni;
-    float                                 fLuminance;
+    GrColor       fColor;
+    UniformHandle fColorUniform;
+    UniformHandle fTextureSizeUni;
+    SkISize       fTextureSize;
+    UniformHandle fLuminanceUni;
+    float         fLuminance;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrColor color,
                                                            GrTexture* texture,
                                                            const GrTextureParams& params,
 #ifdef SK_GAMMA_APPLY_TO_A8
@@ skipping 42 matching lines @@
                                                      const GrGLCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldTextureEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor*
 GrDistanceFieldTextureEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GrGLDistanceFieldTextureEffect, (*this, bt));
 }
 
+void GrDistanceFieldTextureEffect::initBatchTracker(GrBatchTracker* bt, const InitBT& init) const {
+    DistanceFieldBatchTracker* local = bt->cast<DistanceFieldBatchTracker>();
+    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
+                                               SkToBool(fInColor));
+}
+
+bool GrDistanceFieldTextureEffect::onCanMakeEqual(const GrBatchTracker& m,
+                                                  const GrBatchTracker& t) const {
+    const DistanceFieldBatchTracker& mine = m.cast<DistanceFieldBatchTracker>();
+    const DistanceFieldBatchTracker& theirs = t.cast<DistanceFieldBatchTracker>();
+    return CanCombineOutput(mine.fInputColorType, mine.fColor,
+                            theirs.fInputColorType, theirs.fColor);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldTextureEffect);
 
 GrGeometryProcessor* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
                                                               GrContext*,
                                                               const GrDrawTargetCaps&,
                                                               GrTexture* textures[]) {
     int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                       GrProcessorUnitTest::kAlphaTextureIdx;
@@ skipping 22 matching lines @@
                                                 textures[texIdx2], params2,
                                                 random->nextF(),
 #endif
                                                 random->nextBool() ?
                                                     kSimilarity_DistanceFieldEffectFlag : 0,
                                                 random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+struct DistanceFieldNoGammaBatchTracker {
+    GrGPInput fInputColorType;
+    GrColor fColor;
+};
+
 class GrGLDistanceFieldNoGammaTextureEffect : public GrGLGeometryProcessor {
 public:
     GrGLDistanceFieldNoGammaTextureEffect(const GrGeometryProcessor&,
                                           const GrBatchTracker&)
-        : fTextureSize(SkISize::Make(-1, -1)) {}
+        : fColor(GrColor_ILLEGAL), fTextureSize(SkISize::Make(-1, -1)) {}
 
     virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
         const GrDistanceFieldNoGammaTextureEffect& dfTexEffect =
                 args.fGP.cast<GrDistanceFieldNoGammaTextureEffect>();
 
+        const DistanceFieldNoGammaBatchTracker& local =
+                args.fBT.cast<DistanceFieldNoGammaBatchTracker>();
+        GrGLGPBuilder* pb = args.fPB;
         GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         SkAssertResult(fsBuilder->enableFeature(
                                      GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
 
         GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
         GrGLVertToFrag v(kVec2f_GrSLType);
         args.fPB->addVarying("TextureCoords", &v);
 
-        // setup color attribute
-        if(dfTexEffect.inColor()) {
-            args.fPB->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
-        }
+        // setup pass through color
+        this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor,
+                                    dfTexEffect.inColor(), &fColorUniform);
 
         vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
         // setup coord outputs
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(),
                                dfTexEffect.inPosition()->fName);
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(),
                                dfTexEffect.inPosition()->fName);
 
         // setup position varying
@@ skipping 43 matching lines @@
 
             // this gives us a smooth step across approximately one fragment
             fsBuilder->codeAppend("afwidth = " SK_DistanceFieldAAFactor "*length(grad);");
         }
         fsBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);");
 
         fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage);
     }
 
     virtual void setData(const GrGLProgramDataManager& pdman,
-                         const GrGeometryProcessor& proc,
-                         const GrBatchTracker&) SK_OVERRIDE {
+                         const GrPrimitiveProcessor& proc,
+                         const GrBatchTracker& bt) SK_OVERRIDE {
         SkASSERT(fTextureSizeUni.isValid());
 
         GrTexture* texture = proc.texture(0);
         if (texture->width() != fTextureSize.width() || 
             texture->height() != fTextureSize.height()) {
             fTextureSize = SkISize::Make(texture->width(), texture->height());
             pdman.set2f(fTextureSizeUni,
                         SkIntToScalar(fTextureSize.width()),
                         SkIntToScalar(fTextureSize.height()));
         }
+
+        const DistanceFieldNoGammaBatchTracker& local = bt.cast<DistanceFieldNoGammaBatchTracker>();
+        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
+            GrGLfloat c[4];
+            GrColorToRGBAFloat(local.fColor, c);
+            pdman.set4fv(fColorUniform, 1, c);
+            fColor = local.fColor;
+        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& proc,
-                              const GrBatchTracker&,
+                              const GrBatchTracker& bt,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldNoGammaTextureEffect& dfTexEffect =
             proc.cast<GrDistanceFieldNoGammaTextureEffect>();
 
+        const DistanceFieldNoGammaBatchTracker& local = bt.cast<DistanceFieldNoGammaBatchTracker>();
         b->add32(dfTexEffect.getFlags());
+        b->add32(local.fInputColorType);
     }
 
 private:
-    GrGLProgramDataManager::UniformHandle fTextureSizeUni;
-    SkISize                               fTextureSize;
+    UniformHandle fColorUniform;
+    UniformHandle fTextureSizeUni;
+    GrColor       fColor;
+    SkISize       fTextureSize;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldNoGammaTextureEffect::GrDistanceFieldNoGammaTextureEffect(
         GrColor color,
         GrTexture* texture,
         const GrTextureParams& params,
@@ skipping 29 matching lines @@
                                                             const GrGLCaps& caps,
                                                             GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldNoGammaTextureEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor*
 GrDistanceFieldNoGammaTextureEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GrGLDistanceFieldNoGammaTextureEffect, (*this, bt));
 }
 
+void GrDistanceFieldNoGammaTextureEffect::initBatchTracker(GrBatchTracker* bt,
+                                                           const InitBT& init) const {
+    DistanceFieldNoGammaBatchTracker* local = bt->cast<DistanceFieldNoGammaBatchTracker>();
+    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
+                                               SkToBool(fInColor));
+}
+
+bool GrDistanceFieldNoGammaTextureEffect::onCanMakeEqual(const GrBatchTracker& m,
+                                                         const GrBatchTracker& t) const {
+    const DistanceFieldNoGammaBatchTracker& mine = m.cast<DistanceFieldNoGammaBatchTracker>();
+    const DistanceFieldNoGammaBatchTracker& theirs = t.cast<DistanceFieldNoGammaBatchTracker>();
+    return CanCombineOutput(mine.fInputColorType, mine.fColor,
+                            theirs.fInputColorType, theirs.fColor);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldNoGammaTextureEffect);
 
 GrGeometryProcessor* GrDistanceFieldNoGammaTextureEffect::TestCreate(SkRandom* random,
                                                                      GrContext*,
                                                                      const GrDrawTargetCaps&,
                                                                      GrTexture* textures[]) {
     int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx 
                                     : GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
         SkShader::kClamp_TileMode,
         SkShader::kRepeat_TileMode,
         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);
 
     return GrDistanceFieldNoGammaTextureEffect::Create(GrRandomColor(random), textures[texIdx],
                                                        params,
         random->nextBool() ? kSimilarity_DistanceFieldEffectFlag : 0, random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+struct DistanceFieldLCDBatchTracker {
+    GrGPInput fInputColorType;
+    GrColor fColor;
+};
+
 class GrGLDistanceFieldLCDTextureEffect : public GrGLGeometryProcessor {
 public:
     GrGLDistanceFieldLCDTextureEffect(const GrGeometryProcessor&,
                                       const GrBatchTracker&)
-    : fTextureSize(SkISize::Make(-1,-1))
+    : fColor(GrColor_ILLEGAL)
+    , fTextureSize(SkISize::Make(-1,-1))
     , fTextColor(GrColor_ILLEGAL) {}
 
     virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
         const GrDistanceFieldLCDTextureEffect& dfTexEffect =
                 args.fGP.cast<GrDistanceFieldLCDTextureEffect>();
+        const DistanceFieldLCDBatchTracker& local = args.fBT.cast<DistanceFieldLCDBatchTracker>();
+        GrGLGPBuilder* pb = args.fPB;
 
         GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
         GrGLVertToFrag v(kVec2f_GrSLType);
         args.fPB->addVarying("TextureCoords", &v);
         vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
+        // setup pass through color
+        this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL,
+                                    &fColorUniform);
+
         // setup coord outputs
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(),
                                dfTexEffect.inPosition()->fName);
         vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(),
                                dfTexEffect.inPosition()->fName);
 
         // setup position varying
         vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(),
                                vsBuilder->uViewM(), dfTexEffect.inPosition()->fName);
 
@@ skipping 99 matching lines @@
         fsBuilder->codeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName);
         fsBuilder->codeAppend("\tgammaColor = ");
         fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType);
         fsBuilder->codeAppend(";\n");
         fsBuilder->codeAppend("\tval.z = gammaColor.r;\n");
 
         fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage);
     }
 
     virtual void setData(const GrGLProgramDataManager& pdman,
-                         const GrGeometryProcessor& processor,
-                         const GrBatchTracker&) SK_OVERRIDE {
+                         const GrPrimitiveProcessor& processor,
+                         const GrBatchTracker& bt) SK_OVERRIDE {
         SkASSERT(fTextureSizeUni.isValid());
         SkASSERT(fTextColorUni.isValid());
 
         const GrDistanceFieldLCDTextureEffect& dfTexEffect =
                 processor.cast<GrDistanceFieldLCDTextureEffect>();
         GrTexture* texture = processor.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.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;
         }
+
+        const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatchTracker>();
+        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
+            GrGLfloat c[4];
+            GrColorToRGBAFloat(local.fColor, c);
+            pdman.set4fv(fColorUniform, 1, c);
+            fColor = local.fColor;
+        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& processor,
-                              const GrBatchTracker&,
+                              const GrBatchTracker& bt,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldLCDTextureEffect& dfTexEffect =
                 processor.cast<GrDistanceFieldLCDTextureEffect>();
 
+        const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatchTracker>();
         b->add32(dfTexEffect.getFlags());
+        b->add32(local.fInputColorType);
     }
 
 private:
-    GrGLProgramDataManager::UniformHandle fTextureSizeUni;
-    SkISize                               fTextureSize;
-    GrGLProgramDataManager::UniformHandle fTextColorUni;
-    SkColor                               fTextColor;
+    GrColor       fColor;
+    UniformHandle fColorUniform;
+    UniformHandle fTextureSizeUni;
+    SkISize       fTextureSize;
+    UniformHandle fTextColorUni;
+    SkColor       fTextColor;
 
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(
                                                   GrColor color,
                                                   GrTexture* texture, const GrTextureParams& params,
                                                   GrTexture* gamma, const GrTextureParams& gParams,
@@ skipping 28 matching lines @@
                                                         const GrGLCaps& caps,
                                                         GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldLCDTextureEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor*
 GrDistanceFieldLCDTextureEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GrGLDistanceFieldLCDTextureEffect, (*this, bt));
 }
 
+void GrDistanceFieldLCDTextureEffect::initBatchTracker(GrBatchTracker* bt,
+                                                       const InitBT& init) const {
+    DistanceFieldLCDBatchTracker* local = bt->cast<DistanceFieldLCDBatchTracker>();
+    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
+}
+
+bool GrDistanceFieldLCDTextureEffect::onCanMakeEqual(const GrBatchTracker& m,
+                                                     const GrBatchTracker& t) const {
+    const DistanceFieldLCDBatchTracker& mine = m.cast<DistanceFieldLCDBatchTracker>();
+    const DistanceFieldLCDBatchTracker& theirs = t.cast<DistanceFieldLCDBatchTracker>();
+    return CanCombineOutput(mine.fInputColorType, mine.fColor,
+                            theirs.fInputColorType, theirs.fColor);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextureEffect);
 
 GrGeometryProcessor* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random,
                                                                  GrContext*,
                                                                  const GrDrawTargetCaps&,
                                                                  GrTexture* textures[]) {
     int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                       GrProcessorUnitTest::kAlphaTextureIdx;
@@ skipping 17 matching lines @@
                                         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(GrRandomColor(random), textures[texIdx], params,
                                                    textures[texIdx2], params2,
                                                    textColor,
                                                    flags);
 }