Remove uniform color for GrDistanceFieldGeoProc

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 "GrInvariantOutput.h"
 #include "GrTexture.h"
 
 #include "SkDistanceFieldGen.h"
 
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLUtil.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 
 // Assuming a radius of a little less than the diagonal of the fragment
 #define SK_DistanceFieldAAFactor     "0.65"
 
 class GrGLDistanceFieldA8TextGeoProc : public GrGLSLGeometryProcessor {
 public:
     GrGLDistanceFieldA8TextGeoProc()
         : fViewMatrix(SkMatrix::InvalidMatrix())
-        , fColor(GrColor_ILLEGAL)
 #ifdef SK_GAMMA_APPLY_TO_A8
         , fDistanceAdjust(-1.0f)
 #endif
         {}
 
     void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
         const GrDistanceFieldA8TextGeoProc& dfTexEffect =
                 args.fGP.cast<GrDistanceFieldA8TextGeoProc>();
         GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
         SkAssertResult(fragBuilder->enableFeature(
@@ skipping 10 matching lines @@
         // adjust based on gamma
         const char* distanceAdjustUniName = nullptr;
         // width, height, 1/(3*width)
         fDistanceAdjustUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                         kFloat_GrSLType, kDefault_GrSLPrecision,
                                                         "DistanceAdjust", &distanceAdjustUniName);
 #endif
 
         // Setup pass through color
         if (!dfTexEffect.colorIgnored()) {
-            if (dfTexEffect.hasVertexColor()) {
-                varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
-            } else {
-                this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
-                                        &fColorUniform);
-            }
+            varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
         }
 
         // Setup position
         this->setupPosition(vertBuilder,
                             uniformHandler,
                             gpArgs,
                             dfTexEffect.inPosition()->fName,
                             dfTexEffect.viewMatrix(),
                             &fViewMatrixUniform);
 
@@ skipping 91 matching lines @@
         }
 #endif
         const GrDistanceFieldA8TextGeoProc& dfa8gp = proc.cast<GrDistanceFieldA8TextGeoProc>();
 
         if (!dfa8gp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfa8gp.viewMatrix())) {
             fViewMatrix = dfa8gp.viewMatrix();
             float viewMatrix[3 * 3];
             GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
             pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
         }
-
-        if (dfa8gp.color() != fColor && !dfa8gp.hasVertexColor()) {
-            float c[4];
-            GrColorToRGBAFloat(dfa8gp.color(), c);
-            pdman.set4fv(fColorUniform, 1, c);
-            fColor = dfa8gp.color();
-        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& gp,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldA8TextGeoProc& dfTexEffect = gp.cast<GrDistanceFieldA8TextGeoProc>();
         uint32_t key = dfTexEffect.getFlags();
-        key |= dfTexEffect.hasVertexColor() << 16;
-        key |= dfTexEffect.colorIgnored() << 17;
+        key |= dfTexEffect.colorIgnored() << 16;
         key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25;
         b->add32(key);
 
         // Currently we hardcode numbers to convert atlas coordinates to normalized floating point
         SkASSERT(gp.numTextures() == 1);
         GrTexture* atlas = gp.textureAccess(0).getTexture();
         SkASSERT(atlas);
         b->add32(atlas->width());
         b->add32(atlas->height());
     }
 
 private:
     SkMatrix      fViewMatrix;
-    GrColor       fColor;
-    UniformHandle fColorUniform;
     UniformHandle fViewMatrixUniform;
 #ifdef SK_GAMMA_APPLY_TO_A8
     float         fDistanceAdjust;
     UniformHandle fDistanceAdjustUni;
 #endif
 
     typedef GrGLSLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 13 matching lines @@
 #ifdef SK_GAMMA_APPLY_TO_A8
     , fDistanceAdjust(distanceAdjust)
 #endif
     , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
     , fInColor(nullptr)
     , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
     this->initClassID<GrDistanceFieldA8TextGeoProc>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                    kHigh_GrSLPrecision));
-    if (flags & kColorAttr_DistanceFieldEffectFlag) {
-        fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-    }
+    fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                           kVec2s_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
 void GrDistanceFieldA8TextGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                                        GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldA8TextGeoProc::GenKey(*this, caps, b);
 }
 
@@ skipping 30 matching lines @@
                                                     kSimilarity_DistanceFieldEffectFlag : 0,
                                                     d->fRandom->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistanceFieldPathGeoProc : public GrGLSLGeometryProcessor {
 public:
     GrGLDistanceFieldPathGeoProc()
         : fViewMatrix(SkMatrix::InvalidMatrix())
-        , fColor(GrColor_ILLEGAL)
         , fTextureSize(SkISize::Make(-1, -1)) {}
 
     void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
         const GrDistanceFieldPathGeoProc& dfTexEffect = args.fGP.cast<GrDistanceFieldPathGeoProc>();
 
         GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
         SkAssertResult(fragBuilder->enableFeature(
                                      GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
 
         GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
         GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
         GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
         // emit attributes
         varyingHandler->emitAttributes(dfTexEffect);
 
         GrGLSLVertToFrag v(kVec2f_GrSLType);
         varyingHandler->addVarying("TextureCoords", &v, kHigh_GrSLPrecision);
 
         // setup pass through color
         if (!dfTexEffect.colorIgnored()) {
-            if (dfTexEffect.hasVertexColor()) {
-                varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
-            } else {
-                this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
-                                        &fColorUniform);
-            }
+            varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
         }
         vertBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName);
 
         // Setup position
         this->setupPosition(vertBuilder,
                             uniformHandler,
                             gpArgs,
                             dfTexEffect.inPosition()->fName,
                             dfTexEffect.viewMatrix(),
                             &fViewMatrixUniform);
@@ skipping 76 matching lines @@
         }
 
         const GrDistanceFieldPathGeoProc& dfpgp = proc.cast<GrDistanceFieldPathGeoProc>();
 
         if (!dfpgp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfpgp.viewMatrix())) {
             fViewMatrix = dfpgp.viewMatrix();
             float viewMatrix[3 * 3];
             GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
             pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
         }
-
-        if (dfpgp.color() != fColor && !dfpgp.hasVertexColor()) {
-            float c[4];
-            GrColorToRGBAFloat(dfpgp.color(), c);
-            pdman.set4fv(fColorUniform, 1, c);
-            fColor = dfpgp.color();
-        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& gp,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldPathGeoProc& dfTexEffect = gp.cast<GrDistanceFieldPathGeoProc>();
 
         uint32_t key = dfTexEffect.getFlags();
         key |= dfTexEffect.colorIgnored() << 16;
-        key |= dfTexEffect.hasVertexColor() << 17;
         key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25;
         b->add32(key);
     }
 
 private:
-    UniformHandle fColorUniform;
     UniformHandle fTextureSizeUni;
     UniformHandle fViewMatrixUniform;
     SkMatrix      fViewMatrix;
-    GrColor       fColor;
     SkISize       fTextureSize;
 
     typedef GrGLSLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc(
         GrColor color,
         const SkMatrix& viewMatrix,
         GrTexture* texture,
         const GrTextureParams& params,
         uint32_t flags,
         bool usesLocalCoords)
     : fColor(color)
     , fViewMatrix(viewMatrix)
     , fTextureAccess(texture, params)
     , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
     , fInColor(nullptr)
     , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
     this->initClassID<GrDistanceFieldPathGeoProc>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                    kHigh_GrSLPrecision));
-    if (flags & kColorAttr_DistanceFieldEffectFlag) {
-        fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-    }
+    fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                         kVec2f_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
 void GrDistanceFieldPathGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldPathGeoProc::GenKey(*this, caps, b);
 }
 
@@ skipping 27 matching lines @@
                                               d->fRandom->nextBool() ?
                                                       kSimilarity_DistanceFieldEffectFlag : 0,
                                                       d->fRandom->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistanceFieldLCDTextGeoProc : public GrGLSLGeometryProcessor {
 public:
     GrGLDistanceFieldLCDTextGeoProc()
-        : fViewMatrix(SkMatrix::InvalidMatrix()), fColor(GrColor_ILLEGAL) {
+        : fViewMatrix(SkMatrix::InvalidMatrix()) {
         fDistanceAdjust = GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(1.0f, 1.0f, 1.0f);
     }
 
     void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
         const GrDistanceFieldLCDTextGeoProc& dfTexEffect =
                 args.fGP.cast<GrDistanceFieldLCDTextGeoProc>();
 
         GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
         GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
         GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
         // emit attributes
         varyingHandler->emitAttributes(dfTexEffect);
 
         GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
 
         // setup pass through color
         if (!dfTexEffect.colorIgnored()) {
-            if (dfTexEffect.hasVertexColor()) {
-                varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
-            } else {
-                this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
-                                        &fColorUniform);
-            }
+            varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
         }
 
         // Setup position
         this->setupPosition(vertBuilder,
                             uniformHandler,
                             gpArgs,
                             dfTexEffect.inPosition()->fName,
                             dfTexEffect.viewMatrix(),
                             &fViewMatrixUniform);
 
@@ skipping 139 matching lines @@
                         wa.fB);
             fDistanceAdjust = wa;
         }
 
         if (!dflcd.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dflcd.viewMatrix())) {
             fViewMatrix = dflcd.viewMatrix();
             float viewMatrix[3 * 3];
             GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
             pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
         }
-
-        if (dflcd.color() != fColor && !dflcd.hasVertexColor()) {
-            float c[4];
-            GrColorToRGBAFloat(dflcd.color(), c);
-            pdman.set4fv(fColorUniform, 1, c);
-            fColor = dflcd.color();
-        }
     }
 
     static inline void GenKey(const GrGeometryProcessor& gp,
                               const GrGLSLCaps&,
                               GrProcessorKeyBuilder* b) {
         const GrDistanceFieldLCDTextGeoProc& dfTexEffect = gp.cast<GrDistanceFieldLCDTextGeoProc>();
 
         uint32_t key = dfTexEffect.getFlags();
         key |= dfTexEffect.colorIgnored() << 16;
         key |= ComputePosKey(dfTexEffect.viewMatrix()) << 25;
         b->add32(key);
 
         // Currently we hardcode numbers to convert atlas coordinates to normalized floating point
         SkASSERT(gp.numTextures() == 1);
         GrTexture* atlas = gp.textureAccess(0).getTexture();
         SkASSERT(atlas);
         b->add32(atlas->width());
         b->add32(atlas->height());
     }
 
 private:
     SkMatrix                                     fViewMatrix;
-    GrColor                                      fColor;
     UniformHandle                                fViewMatrixUniform;
     UniformHandle                                fColorUniform;
     GrDistanceFieldLCDTextGeoProc::DistanceAdjust fDistanceAdjust;
     UniformHandle                                fDistanceAdjustUni;
 
     typedef GrGLSLGeometryProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(
                                                   GrColor color, const SkMatrix& viewMatrix,
                                                   GrTexture* texture, const GrTextureParams& params,
                                                   DistanceAdjust distanceAdjust,
                                                   uint32_t flags, bool usesLocalCoords)
     : fColor(color)
     , fViewMatrix(viewMatrix)
     , fTextureAccess(texture, params)
     , fDistanceAdjust(distanceAdjust)
     , fFlags(flags & kLCD_DistanceFieldEffectMask)
     , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
     this->initClassID<GrDistanceFieldLCDTextGeoProc>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                    kHigh_GrSLPrecision));
-    if (flags & kColorAttr_DistanceFieldEffectFlag) {
-        fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-    }
+    fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                         kVec2s_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
 void GrDistanceFieldLCDTextGeoProc::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                                         GrProcessorKeyBuilder* b) const {
     GrGLDistanceFieldLCDTextGeoProc::GenKey(*this, caps, b);
 }
 
@@ skipping 23 matching lines @@
     uint32_t flags = kUseLCD_DistanceFieldEffectFlag;
     flags |= d->fRandom->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0;
     flags |= d->fRandom->nextBool() ? kBGR_DistanceFieldEffectFlag : 0;
     return GrDistanceFieldLCDTextGeoProc::Create(GrRandomColor(d->fRandom),
                                                  GrTest::TestMatrix(d->fRandom),
                                                  d->fTextures[texIdx], params,
                                                  wa,
                                                  flags,
                                                  d->fRandom->nextBool());
 }