removing GrDrawEffect

src/gpu/GrOvalRenderer.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 "gl/builders/GrGLProgramBuilder.h"
 #include "GrOvalRenderer.h"
 
@@ skipping 76 matching lines @@
     }
 
     virtual ~CircleEdgeEffect() {}
 
     static const char* Name() { return "CircleEdge"; }
 
     inline bool isStroked() const { return fStroke; }
 
     class GLEffect : public GrGLGeometryProcessor {
     public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+        GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
         : INHERITED (factory) {}
 
         virtual void emitCode(GrGLFullProgramBuilder* builder,
-                              const GrDrawEffect& drawEffect,
+                              const GrEffect& effect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>();
+            const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>();
             const char *vsName, *fsName;
             builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName);
 
             GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();;
             vsBuilder->codeAppendf("\t%s = %s;\n", vsName, circleEffect.inCircleEdge().c_str());
 
             GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
             fsBuilder->codeAppendf("\tfloat d = length(%s.xy);\n", fsName);
             fsBuilder->codeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0);\n", fsName);
             if (circleEffect.isStroked()) {
                 fsBuilder->codeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0, 1.0);\n", fsName);
                 fsBuilder->codeAppend("\tedgeAlpha *= innerAlpha;\n");
             }
 
             fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
         }
 
-        static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+        static void GenKey(const GrEffect& effect, const GrGLCaps&,
                            GrEffectKeyBuilder* b) {
-            const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>();
+            const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>();
             b->add32(circleEffect.isStroked());
         }
 
-        virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
+        virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
 
     private:
         typedef GrGLGeometryProcessor INHERITED;
     };
 
 
 private:
     CircleEdgeEffect(bool stroke)
         : fInCircleEdge(this->addVertexAttrib(
                 GrShaderVar("inCircleEdge",
                             kVec4f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        const CircleEdgeEffect& cee = CastEffect<CircleEdgeEffect>(other);
+        const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
         return cee.fStroke == fStroke;
     }
 
     const GrShaderVar& fInCircleEdge;
     bool fStroke;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
@@ skipping 45 matching lines @@
 
     static const char* Name() { return "EllipseEdge"; }
 
     const GrShaderVar& inEllipseOffset() const { return fInEllipseOffset; }
     const GrShaderVar& inEllipseRadii() const { return fInEllipseRadii; }
 
     inline bool isStroked() const { return fStroke; }
 
     class GLEffect : public GrGLGeometryProcessor {
     public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+        GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
         : INHERITED (factory) {}
 
         virtual void emitCode(GrGLFullProgramBuilder* builder,
-                              const GrDrawEffect& drawEffect,
+                              const GrEffect& effect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>();
+            const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffect>();
 
             const char *vsOffsetName, *fsOffsetName;
             const char *vsRadiiName, *fsRadiiName;
 
             builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName, &fsOffsetName);
 
             GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
             vsBuilder->codeAppendf("%s = %s;", vsOffsetName,
                                    ellipseEffect.inEllipseOffset().c_str());
 
@@ skipping 17 matching lines @@
                 fsBuilder->codeAppend("\ttest = dot(scaledOffset, scaledOffset) - 1.0;\n");
                 fsBuilder->codeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsRadiiName);
                 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\n");
                 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);\n");
             }
 
             fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
         }
 
-        static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+        static void GenKey(const GrEffect& effect, const GrGLCaps&,
                            GrEffectKeyBuilder* b) {
-            const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>();
+            const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffect>();
             b->add32(ellipseEffect.isStroked());
         }
 
-        virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {
+        virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {
         }
 
     private:
         typedef GrGLGeometryProcessor INHERITED;
     };
 
 private:
     EllipseEdgeEffect(bool stroke)
         : fInEllipseOffset(this->addVertexAttrib(
                 GrShaderVar("inEllipseOffset",
                             kVec2f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier)))
         , fInEllipseRadii(this->addVertexAttrib(
                 GrShaderVar("inEllipseRadii",
                             kVec4f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        const EllipseEdgeEffect& eee = CastEffect<EllipseEdgeEffect>(other);
+        const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>();
         return eee.fStroke == fStroke;
     }
 
     const GrShaderVar& fInEllipseOffset;
     const GrShaderVar& fInEllipseRadii;
     bool fStroke;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 53 matching lines @@
 
     static const char* Name() { return "DIEllipseEdge"; }
 
     const GrShaderVar& inEllipseOffsets0() const { return fInEllipseOffsets0; }
     const GrShaderVar& inEllipseOffsets1() const { return fInEllipseOffsets1; }
 
     inline Mode getMode() const { return fMode; }
 
     class GLEffect : public GrGLGeometryProcessor {
     public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+        GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
         : INHERITED (factory) {}
 
         virtual void emitCode(GrGLFullProgramBuilder* builder,
-                              const GrDrawEffect& drawEffect,
+                              const GrEffect& effect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIEllipseEdgeEffect>();
+            const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdgeEffect>();
 
             const char *vsOffsetName0, *fsOffsetName0;
             builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0",
                                       &vsOffsetName0, &fsOffsetName0);
 
             GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
             vsBuilder->codeAppendf("%s = %s;", vsOffsetName0,
                                    ellipseEffect.inEllipseOffsets0().c_str());
             const char *vsOffsetName1, *fsOffsetName1;
             builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1",
@@ skipping 35 matching lines @@
                                        "\t            2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);\n",
                                        fsOffsetName1, fsOffsetName1, fsOffsetName1, fsOffsetName1);
                 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\n");
                 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);\n");
             }
 
             fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
         }
 
-        static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+        static void GenKey(const GrEffect& effect, const GrGLCaps&,
                            GrEffectKeyBuilder* b) {
-            const DIEllipseEdgeEffect& ellipseEffect =
-                drawEffect.castEffect<DIEllipseEdgeEffect>();
+            const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdgeEffect>();
 
             b->add32(ellipseEffect.getMode());
         }
 
-        virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {
+        virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {
         }
 
     private:
         typedef GrGLGeometryProcessor INHERITED;
     };
 
 private:
     DIEllipseEdgeEffect(Mode mode)
         : fInEllipseOffsets0(this->addVertexAttrib(
                 GrShaderVar("inEllipseOffsets0",
                             kVec2f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier)))
         , fInEllipseOffsets1(this->addVertexAttrib(
                 GrShaderVar("inEllipseOffsets1",
                             kVec2f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fMode = mode;
     }
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        const DIEllipseEdgeEffect& eee = CastEffect<DIEllipseEdgeEffect>(other);
+        const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>();
         return eee.fMode == fMode;
     }
 
     const GrShaderVar& fInEllipseOffsets0;
     const GrShaderVar& fInEllipseOffsets1;
     Mode fMode;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 766 matching lines @@
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds);
     }
 
     return true;
 }