Next round of GrGLSLFragmentProcessor-derived class cleanup

GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1661143003

Review URL: https://codereview.chromium.org/1661143003

diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
index 29391fc..8afbee0 100644 (file)
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
@@ -610,9 +610,8 @@ void SkPerlinNoiseShader2::PerlinNoiseShaderContext::shadeSpan(
 class GrGLPerlinNoise2 : public GrGLSLFragmentProcessor {
 public:
     GrGLPerlinNoise2(const GrProcessor&);
-    virtual ~GrGLPerlinNoise2() {}
 
-    virtual void emitCode(EmitArgs&) override;
+    void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 
@@ -1040,24 +1039,18 @@ void GrGLPerlinNoise2::onSetData(const GrGLSLProgramDataManager& pdman,
 
 class GrGLImprovedPerlinNoise : public GrGLSLFragmentProcessor {
 public:
-    GrGLImprovedPerlinNoise(const GrProcessor&);
-    virtual ~GrGLImprovedPerlinNoise() {}
+    void emitCode(EmitArgs&) override;
 
-    virtual void emitCode(EmitArgs&) override;
-
-    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
+    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
-
-    SkScalar fZ;
     GrGLSLProgramDataManager::UniformHandle fZUni;
     GrGLSLProgramDataManager::UniformHandle fOctavesUni;
     GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
 
-private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
@@ -1084,11 +1077,10 @@ public:
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
-        return new GrGLImprovedPerlinNoise(*this);
+        return new GrGLImprovedPerlinNoise;
     }
 
-    virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
-                                       GrProcessorKeyBuilder* b) const override {
+    void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GrGLImprovedPerlinNoise::GenKey(*this, caps, b);
     }
 
@@ -1153,10 +1145,6 @@ const GrFragmentProcessor* GrImprovedPerlinNoiseEffect::TestCreate(GrProcessorTe
                                        kNone_SkFilterQuality);
 }
 
-GrGLImprovedPerlinNoise::GrGLImprovedPerlinNoise(const GrProcessor& processor)
-  : fZ(processor.cast<GrImprovedPerlinNoiseEffect>().z()) {
-}
-
 void GrGLImprovedPerlinNoise::emitCode(EmitArgs& args) {
     GrGLSLFragmentBuilder* fsBuilder = args.fFragBuilder;
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;

diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 71d9aa2..adb227d 100644 (file)
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -149,7 +149,6 @@ protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
-
     GrGLSLProgramDataManager::UniformHandle fInnerThresholdVar;
     GrGLSLProgramDataManager::UniformHandle fOuterThresholdVar;
 

diff --git a/src/effects/SkArithmeticMode_gpu.cpp b/src/effects/SkArithmeticMode_gpu.cpp
index 709f59d..d3fb609 100644 (file)
--- a/src/effects/SkArithmeticMode_gpu.cpp
+++ b/src/effects/SkArithmeticMode_gpu.cpp
@@ -75,7 +75,7 @@ public:
                             arith.enforcePMColor());
     }
 
-    static void GenKey(const GrProcessor& proc, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) {
+    static void GenKey(const GrProcessor& proc, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
         const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>();
         uint32_t key = arith.enforcePMColor() ? 1 : 0;
         b->add32(key);

diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index d55c669..5a7fc50 100644 (file)
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -646,6 +646,7 @@ public:
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
+    GrSLPrecision precision() const { return fPrecision; }
 
 private:
     GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
@@ -673,12 +674,9 @@ private:
 
 class GrGLRectBlurEffect : public GrGLSLFragmentProcessor {
 public:
-    GrGLRectBlurEffect(const GrProcessor&, GrSLPrecision precision) 
-    : fPrecision(precision) {
-    }
     void emitCode(EmitArgs&) override;
 
-    static void GenKey(GrSLPrecision precision, GrProcessorKeyBuilder* b);
+    static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
@@ -688,7 +686,6 @@ private:
 
     UniformHandle       fProxyRectUniform;
     UniformHandle       fProfileSizeUniform;
-    GrSLPrecision       fPrecision;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
@@ -710,21 +707,26 @@ void OutputRectBlurProfileLookup(GrGLSLFragmentBuilder* fragBuilder,
 }
 
 
-void GrGLRectBlurEffect::GenKey(GrSLPrecision precision, GrProcessorKeyBuilder* b) {
-    b->add32(precision);
+void GrGLRectBlurEffect::GenKey(const GrProcessor& proc, const GrGLSLCaps&,
+                                GrProcessorKeyBuilder* b) {
+    const GrRectBlurEffect& rbe = proc.cast<GrRectBlurEffect>();
+
+    b->add32(rbe.precision());
 }
 
 
 void GrGLRectBlurEffect::emitCode(EmitArgs& args) {
+    const GrRectBlurEffect& rbe = args.fFp.cast<GrRectBlurEffect>();
+
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
     const char *rectName;
     const char *profileSizeName;
 
-    const char* precisionString = GrGLSLShaderVar::PrecisionString(args.fGLSLCaps, fPrecision);
+    const char* precisionString = GrGLSLShaderVar::PrecisionString(args.fGLSLCaps, rbe.precision());
     fProxyRectUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                    kVec4f_GrSLType,
-                                                   fPrecision,
+                                                   rbe.precision(),
                                                    "proxyRect",
                                                    &rectName);
     fProfileSizeUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
@@ -814,11 +816,11 @@ GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *b
 
 void GrRectBlurEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                              GrProcessorKeyBuilder* b) const {
-    GrGLRectBlurEffect::GenKey(fPrecision, b);
+    GrGLRectBlurEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* GrRectBlurEffect::onCreateGLSLInstance() const {
-    return new GrGLRectBlurEffect(*this, fPrecision);
+    return new GrGLRectBlurEffect;
 }
 
 bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& sBase) const {

diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index e861d58..e2b7922 100644 (file)
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -312,20 +312,14 @@ void SkDisplacementMapEffect::toString(SkString* str) const {
 #if SK_SUPPORT_GPU
 class GrGLDisplacementMapEffect : public GrGLSLFragmentProcessor {
 public:
-    GrGLDisplacementMapEffect(const GrProcessor&);
-
     void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 
-    const GrTextureDomain::GLDomain& glDomain() const { return fGLDomain; }
-
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
-    SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
-    SkDisplacementMapEffect::ChannelSelectorType fYChannelSelector;
     GrGLSLProgramDataManager::UniformHandle fScaleUni;
     GrTextureDomain::GLDomain fGLDomain;
 
@@ -358,11 +352,10 @@ public:
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
-        return new GrGLDisplacementMapEffect(*this);
+        return new GrGLDisplacementMapEffect;
     }
 
-    virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
-                                       GrProcessorKeyBuilder* b) const override {
+    void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GrGLDisplacementMapEffect::GenKey(*this, caps, b);
     }
 
@@ -542,13 +535,9 @@ const GrFragmentProcessor* GrDisplacementMapEffect::TestCreate(GrProcessorTestDa
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrGLDisplacementMapEffect::GrGLDisplacementMapEffect(const GrProcessor& proc)
-    : fXChannelSelector(proc.cast<GrDisplacementMapEffect>().xChannelSelector())
-    , fYChannelSelector(proc.cast<GrDisplacementMapEffect>().yChannelSelector()) {
-}
-
 void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
-    const GrTextureDomain& domain = args.fFp.cast<GrDisplacementMapEffect>().domain();
+    const GrDisplacementMapEffect& displacementMap = args.fFp.cast<GrDisplacementMapEffect>();
+    const GrTextureDomain& domain = displacementMap.domain();
 
     fScaleUni = args.fUniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                  kVec2f_GrSLType, kDefault_GrSLPrecision, "Scale");
@@ -573,7 +562,7 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
     fragBuilder->codeAppendf("\t\tvec2 %s = %s + %s*(%s.",
                              cCoords, coords2D.c_str(), scaleUni, dColor);
 
-    switch (fXChannelSelector) {
+    switch (displacementMap.xChannelSelector()) {
       case SkDisplacementMapEffect::kR_ChannelSelectorType:
         fragBuilder->codeAppend("r");
         break;
@@ -591,7 +580,7 @@ void GrGLDisplacementMapEffect::emitCode(EmitArgs& args) {
         SkDEBUGFAIL("Unknown X channel selector");
     }
 
-    switch (fYChannelSelector) {
+    switch (displacementMap.yChannelSelector()) {
       case SkDisplacementMapEffect::kR_ChannelSelectorType:
         fragBuilder->codeAppend("r");
         break;

diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 46d02aa..7a80032 100644 (file)
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -62,7 +62,7 @@ public:
 
     class GLSLProcessor : public GrGLSLFragmentProcessor {
     public:
-        static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {}
+        static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
 
         void emitCode(EmitArgs& args) override {
             if (nullptr == args.fInputColor) {

diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 0a4bc2a..bc5bdee 100644 (file)
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -253,37 +253,23 @@ private:
 
 class GrGLMorphologyEffect : public GrGLSLFragmentProcessor {
 public:
-    GrGLMorphologyEffect(const GrProcessor&);
-
     void emitCode(EmitArgs&) override;
 
-    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
+    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
-    int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
-
-    int                                   fRadius;
-    Gr1DKernelEffect::Direction           fDirection;
-    bool                                  fUseRange;
-    GrMorphologyEffect::MorphologyType    fType;
     GrGLSLProgramDataManager::UniformHandle fPixelSizeUni;
     GrGLSLProgramDataManager::UniformHandle fRangeUni;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
-GrGLMorphologyEffect::GrGLMorphologyEffect(const GrProcessor& proc) {
-    const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
-    fRadius = m.radius();
-    fDirection = m.direction();
-    fUseRange = m.useRange();
-    fType = m.type();
-}
-
 void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
+    const GrMorphologyEffect& me = args.fFp.cast<GrMorphologyEffect>();
+
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fPixelSizeUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                kFloat_GrSLType, kDefault_GrSLPrecision,
@@ -297,7 +283,7 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* func;
-    switch (fType) {
+    switch (me.type()) {
         case GrMorphologyEffect::kErode_MorphologyType:
             fragBuilder->codeAppendf("\t\t%s = vec4(1, 1, 1, 1);\n", args.fOutputColor);
             func = "min";
@@ -313,7 +299,7 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
     }
 
     const char* dir;
-    switch (fDirection) {
+    switch (me.direction()) {
         case Gr1DKernelEffect::kX_Direction:
             dir = "x";
             break;
@@ -325,24 +311,26 @@ void GrGLMorphologyEffect::emitCode(EmitArgs& args) {
             dir = ""; // suppress warning
     }
 
+    int width = GrMorphologyEffect::WidthFromRadius(me.radius());
+
     // vec2 coord = coord2D;
     fragBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str());
     // coord.x -= radius * pixelSize;
-    fragBuilder->codeAppendf("\t\tcoord.%s -= %d.0 * %s; \n", dir, fRadius, pixelSizeInc);
-    if (fUseRange) {
+    fragBuilder->codeAppendf("\t\tcoord.%s -= %d.0 * %s; \n", dir, me.radius(), pixelSizeInc);
+    if (me.useRange()) {
         // highBound = min(highBound, coord.x + (width-1) * pixelSize);
         fragBuilder->codeAppendf("\t\tfloat highBound = min(%s.y, coord.%s + %f * %s);",
-                                 range, dir, float(width() - 1), pixelSizeInc);
+                                 range, dir, float(width - 1), pixelSizeInc);
         // coord.x = max(lowBound, coord.x);
         fragBuilder->codeAppendf("\t\tcoord.%s = max(%s.x, coord.%s);", dir, range, dir);
     }
-    fragBuilder->codeAppendf("\t\tfor (int i = 0; i < %d; i++) {\n", width());
+    fragBuilder->codeAppendf("\t\tfor (int i = 0; i < %d; i++) {\n", width);
     fragBuilder->codeAppendf("\t\t\t%s = %s(%s, ", args.fOutputColor, func, args.fOutputColor);
     fragBuilder->appendTextureLookup(args.fSamplers[0], "coord");
     fragBuilder->codeAppend(");\n");
     // coord.x += pixelSize;
     fragBuilder->codeAppendf("\t\t\tcoord.%s += %s;\n", dir, pixelSizeInc);
-    if (fUseRange) {
+    if (me.useRange()) {
         // coord.x = min(highBound, coord.x);
         fragBuilder->codeAppendf("\t\t\tcoord.%s = min(highBound, coord.%s);", dir, dir);
     }
@@ -358,21 +346,19 @@ void GrGLMorphologyEffect::GenKey(const GrProcessor& proc,
     uint32_t key = static_cast<uint32_t>(m.radius());
     key |= (m.type() << 8);
     key |= (m.direction() << 9);
-    if (m.useRange()) key |= 1 << 10;
+    if (m.useRange()) {
+        key |= 1 << 10;
+    }
     b->add32(key);
 }
 
 void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
-                                   const GrProcessor& proc) {
+                                     const GrProcessor& proc) {
     const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
     GrTexture& texture = *m.texture(0);
-    // the code we generated was for a specific kernel radius, direction and bound usage
-    SkASSERT(m.radius() == fRadius);
-    SkASSERT(m.direction() == fDirection);
-    SkASSERT(m.useRange() == fUseRange);
 
     float pixelSize = 0.0f;
-    switch (fDirection) {
+    switch (m.direction()) {
         case Gr1DKernelEffect::kX_Direction:
             pixelSize = 1.0f / texture.width();
             break;
@@ -384,9 +370,9 @@ void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
     }
     pdman.set1f(fPixelSizeUni, pixelSize);
 
-    if (fUseRange) {
+    if (m.useRange()) {
         const float* range = m.range();
-        if (fDirection && texture.origin() == kBottomLeft_GrSurfaceOrigin) {
+        if (m.direction() && texture.origin() == kBottomLeft_GrSurfaceOrigin) {
             pdman.set2f(fRangeUni, 1.0f - range[1], 1.0f - range[0]);
         } else {
             pdman.set2f(fRangeUni, range[0], range[1]);
@@ -426,7 +412,7 @@ void GrMorphologyEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 }
 
 GrGLSLFragmentProcessor* GrMorphologyEffect::onCreateGLSLInstance() const {
-    return new GrGLMorphologyEffect(*this);
+    return new GrGLMorphologyEffect;
 }
 bool GrMorphologyEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrMorphologyEffect& s = sBase.cast<GrMorphologyEffect>();

diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index f66655c..c9096f4 100644 (file)
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -472,21 +472,15 @@ void SkPerlinNoiseShader::PerlinNoiseShaderContext::shadeSpan(
 
 class GrGLPerlinNoise : public GrGLSLFragmentProcessor {
 public:
-    GrGLPerlinNoise(const GrProcessor&);
-
     void emitCode(EmitArgs&) override;
 
-    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
+    static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
-
     GrGLSLProgramDataManager::UniformHandle fStitchDataUni;
-    SkPerlinNoiseShader::Type               fType;
-    bool                                    fStitchTiles;
-    int                                     fNumOctaves;
     GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
 
     typedef GrGLSLFragmentProcessor INHERITED;
@@ -519,7 +513,7 @@ public:
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
-        return new GrGLPerlinNoise(*this);
+        return new GrGLPerlinNoise;
     }
 
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
@@ -597,13 +591,9 @@ const GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData*
                                        kNone_SkFilterQuality);
 }
 
-GrGLPerlinNoise::GrGLPerlinNoise(const GrProcessor& processor)
-  : fType(processor.cast<GrPerlinNoiseEffect>().type())
-  , fStitchTiles(processor.cast<GrPerlinNoiseEffect>().stitchTiles())
-  , fNumOctaves(processor.cast<GrPerlinNoiseEffect>().numOctaves()) {
-}
-
 void GrGLPerlinNoise::emitCode(EmitArgs& args) {
+    const GrPerlinNoiseEffect& pne = args.fFp.cast<GrPerlinNoiseEffect>();
+
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     SkString vCoords = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
@@ -614,7 +604,7 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
     const char* baseFrequencyUni = uniformHandler->getUniformCStr(fBaseFrequencyUni);
 
     const char* stitchDataUni = nullptr;
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         fStitchDataUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                     "stitchData");
@@ -667,7 +657,7 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
         noiseSmooth, fractVal, fractVal, fractVal);
 
     // Adjust frequencies if we're stitching tiles
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         noiseCode.appendf("\n\tif(%s.x >= %s.x) { %s.x -= %s.x; }",
                           floorVal, stitchData, floorVal, stitchData);
         noiseCode.appendf("\n\tif(%s.y >= %s.y) { %s.y -= %s.y; }",
@@ -776,7 +766,7 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
     noiseCode.appendf("\n\treturn mix(%s.x, %s.y, %s.y);\n", ab, ab, noiseSmooth);
 
     SkString noiseFuncName;
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         fragBuilder->emitFunction(kFloat_GrSLType,
                                   "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
                                   gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
@@ -793,21 +783,21 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
     // Clear the color accumulator
     fragBuilder->codeAppendf("\n\t\t%s = vec4(0.0);", args.fOutputColor);
 
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         // Set up TurbulenceInitial stitch values.
-        fragBuilder->codeAppendf("\n\t\tvec2 %s = %s;", stitchData, stitchDataUni);
+        fragBuilder->codeAppendf("vec2 %s = %s;", stitchData, stitchDataUni);
     }
 
-    fragBuilder->codeAppendf("\n\t\tfloat %s = 1.0;", ratio);
+    fragBuilder->codeAppendf("float %s = 1.0;", ratio);
 
     // Loop over all octaves
-    fragBuilder->codeAppendf("\n\t\tfor (int octave = 0; octave < %d; ++octave) {", fNumOctaves);
+    fragBuilder->codeAppendf("for (int octave = 0; octave < %d; ++octave) {", pne.numOctaves());
 
-    fragBuilder->codeAppendf("\n\t\t\t%s += ", args.fOutputColor);
-    if (fType != SkPerlinNoiseShader::kFractalNoise_Type) {
+    fragBuilder->codeAppendf("%s += ", args.fOutputColor);
+    if (pne.type() != SkPerlinNoiseShader::kFractalNoise_Type) {
         fragBuilder->codeAppend("abs(");
     }
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         fragBuilder->codeAppendf(
             "vec4(\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s),"
                  "\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s))",
@@ -824,7 +814,7 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
             noiseFuncName.c_str(), chanCoordB, noiseVec,
             noiseFuncName.c_str(), chanCoordA, noiseVec);
     }
-    if (fType != SkPerlinNoiseShader::kFractalNoise_Type) {
+    if (pne.type() != SkPerlinNoiseShader::kFractalNoise_Type) {
         fragBuilder->codeAppendf(")"); // end of "abs("
     }
     fragBuilder->codeAppendf(" * %s;", ratio);
@@ -832,12 +822,12 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
     fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", noiseVec);
     fragBuilder->codeAppendf("\n\t\t\t%s *= 0.5;", ratio);
 
-    if (fStitchTiles) {
+    if (pne.stitchTiles()) {
         fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", stitchData);
     }
     fragBuilder->codeAppend("\n\t\t}"); // end of the for loop on octaves
 
-    if (fType == SkPerlinNoiseShader::kFractalNoise_Type) {
+    if (pne.type() == SkPerlinNoiseShader::kFractalNoise_Type) {
         // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
         // by fractalNoise and (turbulenceFunctionResult) by turbulence.
         fragBuilder->codeAppendf("\n\t\t%s = %s * vec4(0.5) + vec4(0.5);",

diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index c06e436..9f7289f 100644 (file)
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -379,7 +379,7 @@ class GLColorTableEffect : public GrGLSLFragmentProcessor {
 public:
     void emitCode(EmitArgs&) override;
 
-    static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {}
+    static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;

diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index 03b0fa4..7544b7b 100644 (file)
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -63,7 +63,7 @@ protected:
 
 private:
     GrGLSLProgramDataManager::UniformHandle fColorUniform;
-    GrColor                               fPrevColor;
+    GrColor                                 fPrevColor;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };

diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index f95d1a2..fdc4a39 100644 (file)
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -94,7 +94,8 @@ protected:
 
 private:
     GrGLSLProgramDataManager::UniformHandle fRectUniform;
-    SkRect                                fPrevRect;
+    SkRect                                  fPrevRect;
+
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
@@ -179,7 +180,7 @@ protected:
 
 private:
     GrGLSLProgramDataManager::UniformHandle fEdgeUniform;
-    SkScalar                              fPrevEdges[3 * GrConvexPolyEffect::kMaxEdges];
+    SkScalar                                fPrevEdges[3 * GrConvexPolyEffect::kMaxEdges];
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 

diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index adb62ae..f3bd028 100644 (file)
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -16,8 +16,6 @@ typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
 
 class GrGLConvolutionEffect : public GrGLSLFragmentProcessor {
 public:
-    GrGLConvolutionEffect(const GrProcessor&);
-
     void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
@@ -26,13 +24,6 @@ protected:
     void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor&) override;
 
 private:
-    int width() const { return Gr1DKernelEffect::WidthFromRadius(fRadius); }
-    bool useBounds() const { return fUseBounds; }
-    Gr1DKernelEffect::Direction direction() const { return fDirection; }
-
-    int                 fRadius;
-    bool                fUseBounds;
-    Gr1DKernelEffect::Direction    fDirection;
     UniformHandle       fKernelUni;
     UniformHandle       fImageIncrementUni;
     UniformHandle       fBoundsUni;
@@ -40,37 +31,34 @@ private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
-GrGLConvolutionEffect::GrGLConvolutionEffect(const GrProcessor& processor) {
-    const GrConvolutionEffect& c = processor.cast<GrConvolutionEffect>();
-    fRadius = c.radius();
-    fUseBounds = c.useBounds();
-    fDirection = c.direction();
-}
-
 void GrGLConvolutionEffect::emitCode(EmitArgs& args) {
+    const GrConvolutionEffect& ce = args.fFp.cast<GrConvolutionEffect>();
+
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fImageIncrementUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                     "ImageIncrement");
-    if (this->useBounds()) {
+    if (ce.useBounds()) {
         fBoundsUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                 kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                 "Bounds");
     }
+
+    int width = Gr1DKernelEffect::WidthFromRadius(ce.radius());
+
     fKernelUni = uniformHandler->addUniformArray(GrGLSLUniformHandler::kFragment_Visibility,
                                                  kFloat_GrSLType, kDefault_GrSLPrecision,
-                                                 "Kernel", this->width());
+                                                 "Kernel", width);
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
 
-    fragBuilder->codeAppendf("\t\t%s = vec4(0, 0, 0, 0);\n", args.fOutputColor);
+    fragBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);", args.fOutputColor);
 
-    int width = this->width();
     const GrGLSLShaderVar& kernel = uniformHandler->getUniformVariable(fKernelUni);
     const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
 
-    fragBuilder->codeAppendf("\t\tvec2 coord = %s - %d.0 * %s;\n", coords2D.c_str(), fRadius, imgInc);
+    fragBuilder->codeAppendf("vec2 coord = %s - %d.0 * %s;", coords2D.c_str(), ce.radius(), imgInc);
 
     // Manually unroll loop because some drivers don't; yields 20-30% speedup.
     for (int i = 0; i < width; i++) {
@@ -79,19 +67,19 @@ void GrGLConvolutionEffect::emitCode(EmitArgs& args) {
         index.appendS32(i);
         kernel.appendArrayAccess(index.c_str(), &kernelIndex);
 
-        if (this->useBounds()) {
+        if (ce.useBounds()) {
             // We used to compute a bool indicating whether we're in bounds or not, cast it to a
             // float, and then mul weight*texture_sample by the float. However, the Adreno 430 seems
             // to have a bug that caused corruption.
             const char* bounds = uniformHandler->getUniformCStr(fBoundsUni);
-            const char* component = this->direction() == Gr1DKernelEffect::kY_Direction ? "y" : "x";
+            const char* component = ce.direction() == Gr1DKernelEffect::kY_Direction ? "y" : "x";
             fragBuilder->codeAppendf("if (coord.%s >= %s.x && coord.%s <= %s.y) {",
                                      component, bounds, component, bounds);
         }
         fragBuilder->codeAppendf("\t\t%s += ", args.fOutputColor);
         fragBuilder->appendTextureLookup(args.fSamplers[0], "coord");
         fragBuilder->codeAppendf(" * %s;\n", kernelIndex.c_str());
-        if (this->useBounds()) {
+        if (ce.useBounds()) {
             fragBuilder->codeAppend("}");
         }
         fragBuilder->codeAppendf("\t\tcoord += %s;\n", imgInc);
@@ -106,8 +94,7 @@ void GrGLConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                       const GrProcessor& processor) {
     const GrConvolutionEffect& conv = processor.cast<GrConvolutionEffect>();
     GrTexture& texture = *conv.texture(0);
-    // the code we generated was for a specific kernel radius
-    SkASSERT(conv.radius() == fRadius);
+
     float imageIncrement[2] = { 0 };
     float ySign = texture.origin() != kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
     switch (conv.direction()) {
@@ -130,7 +117,9 @@ void GrGLConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
             pdman.set2f(fBoundsUni, bounds[0], bounds[1]);
         }
     }
-    pdman.set1fv(fKernelUni, this->width(), conv.kernel());
+    int width = Gr1DKernelEffect::WidthFromRadius(conv.radius());
+
+    pdman.set1fv(fKernelUni, width, conv.kernel());
 }
 
 void GrGLConvolutionEffect::GenKey(const GrProcessor& processor, const GrGLSLCaps&,
@@ -201,7 +190,7 @@ void GrConvolutionEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 }
 
 GrGLSLFragmentProcessor* GrConvolutionEffect::onCreateGLSLInstance() const  {
-    return new GrGLConvolutionEffect(*this);
+    return new GrGLConvolutionEffect;
 }
 
 bool GrConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const {

diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
index 6d411c4..a7f829e 100644 (file)
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -12,7 +12,6 @@
 
 class GrGLMatrixConvolutionEffect : public GrGLSLFragmentProcessor {
 public:
-    GrGLMatrixConvolutionEffect(const GrProcessor&);
     void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
@@ -22,8 +21,6 @@ protected:
 
 private:
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
-    SkISize                     fKernelSize;
-    bool                        fConvolveAlpha;
 
     UniformHandle               fKernelUni;
     UniformHandle               fImageIncrementUni;
@@ -35,14 +32,13 @@ private:
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
-GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrProcessor& processor) {
-    const GrMatrixConvolutionEffect& m = processor.cast<GrMatrixConvolutionEffect>();
-    fKernelSize = m.kernelSize();
-    fConvolveAlpha = m.convolveAlpha();
-}
-
 void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
-    const GrTextureDomain& domain = args.fFp.cast<GrMatrixConvolutionEffect>().domain();
+    const GrMatrixConvolutionEffect& mce = args.fFp.cast<GrMatrixConvolutionEffect>();
+    const GrTextureDomain& domain = mce.domain();
+
+    int kWidth = mce.kernelSize().width();
+    int kHeight = mce.kernelSize().height();
+
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fImageIncrementUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
@@ -50,7 +46,7 @@ void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
     fKernelUni = uniformHandler->addUniformArray(GrGLSLUniformHandler::kFragment_Visibility,
                                                  kFloat_GrSLType, kDefault_GrSLPrecision,
                                                  "Kernel",
-                                                 fKernelSize.width() * fKernelSize.height());
+                                                 kWidth * kHeight);
     fKernelOffsetUni = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
                                                   kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                   "KernelOffset");
@@ -64,8 +60,6 @@ void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
     const char* kernel = uniformHandler->getUniformCStr(fKernelUni);
     const char* gain = uniformHandler->getUniformCStr(fGainUni);
     const char* bias = uniformHandler->getUniformCStr(fBiasUni);
-    int kWidth = fKernelSize.width();
-    int kHeight = fKernelSize.height();
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
@@ -86,14 +80,14 @@ void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
                                   "c",
                                   coord,
                                   args.fSamplers[0]);
-            if (!fConvolveAlpha) {
+            if (!mce.convolveAlpha()) {
                 fragBuilder->codeAppend("c.rgb /= c.a;");
                 fragBuilder->codeAppend("c.rgb = clamp(c.rgb, 0.0, 1.0);");
             }
             fragBuilder->codeAppend("sum += c * k;");
         }
     }
-    if (fConvolveAlpha) {
+    if (mce.convolveAlpha()) {
         fragBuilder->codeAppendf("%s = sum * %s + %s;", args.fOutputColor, gain, bias);
         fragBuilder->codeAppendf("%s.rgb = clamp(%s.rgb, 0.0, %s.a);",
                                  args.fOutputColor, args.fOutputColor, args.fOutputColor);
@@ -129,15 +123,14 @@ void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdma
                                             const GrProcessor& processor) {
     const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
     GrTexture& texture = *conv.texture(0);
-    // the code we generated was for a specific kernel size
-    SkASSERT(conv.kernelSize() == fKernelSize);
+
     float imageIncrement[2];
     float ySign = texture.origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
     imageIncrement[0] = 1.0f / texture.width();
     imageIncrement[1] = ySign / texture.height();
     pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
     pdman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
-    pdman.set1fv(fKernelUni, fKernelSize.width() * fKernelSize.height(), conv.kernel());
+    pdman.set1fv(fKernelUni, conv.kernelSize().width() * conv.kernelSize().height(), conv.kernel());
     pdman.set1f(fGainUni, conv.gain());
     pdman.set1f(fBiasUni, conv.bias());
     fDomain.setData(pdman, conv.domain(), texture.origin());
@@ -166,16 +159,13 @@ GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
     fKernelOffset[1] = static_cast<float>(kernelOffset.y());
 }
 
-GrMatrixConvolutionEffect::~GrMatrixConvolutionEffect() {
-}
-
 void GrMatrixConvolutionEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                                       GrProcessorKeyBuilder* b) const {
     GrGLMatrixConvolutionEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLSLInstance() const  {
-    return new GrGLMatrixConvolutionEffect(*this);
+    return new GrGLMatrixConvolutionEffect;
 }
 
 bool GrMatrixConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const {

diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h
index b114abe..066da65 100644 (file)
--- a/src/gpu/effects/GrMatrixConvolutionEffect.h
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.h
@@ -42,8 +42,6 @@ public:
                                                SkScalar sigmaX,
                                                SkScalar sigmaY);
 
-    virtual ~GrMatrixConvolutionEffect();
-
     const SkIRect& bounds() const { return fBounds; }
     const SkISize& kernelSize() const { return fKernelSize; }
     const float* kernelOffset() const { return fKernelOffset; }

diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 44bd928..84e49cb 100644 (file)
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -143,7 +143,7 @@ protected:
 private:
     GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
     GrGLSLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
-    SkRRect                               fPrevRRect;
+    SkRRect                                 fPrevRRect;
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 

diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index 6f47b04..96a53f5 100644 (file)
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -15,12 +15,12 @@ class GrGLSimpleTextureEffect : public GrGLSLFragmentProcessor {
 public:
     void emitCode(EmitArgs& args) override {
         GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
-        fragBuilder->codeAppendf("\t%s = ", args.fOutputColor);
+        fragBuilder->codeAppendf("%s = ", args.fOutputColor);
         fragBuilder->appendTextureLookupAndModulate(args.fInputColor,
                                                   args.fSamplers[0],
                                                   args.fCoords[0].c_str(),
                                                   args.fCoords[0].getType());
-        fragBuilder->codeAppend(";\n");
+        fragBuilder->codeAppend(";");
     }
 
 private: