removing GrDrawEffect

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 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 "GrDashingEffect.h"
 
@@ skipping 460 matching lines @@
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect : public GrGLGeometryProcessor {
 public:
-    GLDashingCircleEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+    GLDashingCircleEffect(const GrBackendEffectFactory&, const GrEffect&);
 
     virtual void emitCode(GrGLFullProgramBuilder* builder,
-                          const GrDrawEffect& drawEffect,
+                          const GrEffect& effect,
                           const GrEffectKey& key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
-    static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+    static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
-    virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
 
 private:
     GrGLProgramDataManager::UniformHandle fParamUniform;
     SkScalar                              fPrevRadius;
     SkScalar                              fPrevCenterX;
     SkScalar                              fPrevIntervalLength;
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendEffectFactory& factory,
-                                             const GrDrawEffect& drawEffect)
+                                             const GrEffect& effect)
     : INHERITED (factory) {
     fPrevRadius = SK_ScalarMin;
     fPrevCenterX = SK_ScalarMin;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingCircleEffect::emitCode(GrGLFullProgramBuilder* builder,
-                                    const GrDrawEffect& drawEffect,
+                                    const GrEffect& effect,
                                     const GrEffectKey& key,
                                     const char* outputColor,
                                     const char* inputColor,
                                     const TransformedCoordsArray&,
                                     const TextureSamplerArray& samplers) {
-    const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
+    const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
     const char *paramName;
     // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x coord, and
     // the total interval length of the dash.
     fParamUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                        kVec3f_GrSLType,
                                        "params",
                                        &paramName);
 
     const char *vsCoordName, *fsCoordName;
     builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName);
@@ skipping 13 matching lines @@
         fsBuilder->codeAppend("\t\tdiff = 1.0 - diff;\n");
         fsBuilder->codeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n");
     } else {
         fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n");
         fsBuilder->codeAppendf("\t\talpha *=  dist < %s.x + 0.5 ? 1.0 : 0.0;\n", paramName);
     }
     fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor,
                            (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
 }
 
-void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
-    const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
+void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
+    const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
     SkScalar radius = dce.getRadius();
     SkScalar centerX = dce.getCenterX();
     SkScalar intervalLength = dce.getIntervalLength();
     if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fPrevIntervalLength) {
         pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength);
         fPrevRadius = radius;
         fPrevCenterX = centerX;
         fPrevIntervalLength = intervalLength;
     }
 }
 
-void GLDashingCircleEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+void GLDashingCircleEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
                                    GrEffectKeyBuilder* b) {
-    const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
+    const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
     b->add32(dce.getEdgeType());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrEffect* DashingCircleEffect::Create(GrEffectEdgeType edgeType, const DashInfo& info,
                                       SkScalar radius) {
     if (info.fCount != 2 || info.fIntervals[0] != 0) {
         return NULL;
     }
@@ skipping 18 matching lines @@
                                                  kVec2f_GrSLType,
                                                  GrShaderVar::kAttribute_TypeModifier))) {
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     fIntervalLength = onLen + offLen;
     fRadius = radius;
     fCenterX = SkScalarHalf(offLen);
 }
 
 bool DashingCircleEffect::onIsEqual(const GrEffect& other) const {
-    const DashingCircleEffect& dce = CastEffect<DashingCircleEffect>(other);
+    const DashingCircleEffect& dce = other.cast<DashingCircleEffect>();
     return (fEdgeType == dce.fEdgeType &&
             fIntervalLength == dce.fIntervalLength &&
             fRadius == dce.fRadius &&
             fCenterX == dce.fCenterX);
 }
 
 GR_DEFINE_EFFECT_TEST(DashingCircleEffect);
 
 GrEffect* DashingCircleEffect::TestCreate(SkRandom* random,
                                           GrContext*,
@@ skipping 64 matching lines @@
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect : public GrGLGeometryProcessor {
 public:
-    GLDashingLineEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+    GLDashingLineEffect(const GrBackendEffectFactory&, const GrEffect&);
 
     virtual void emitCode(GrGLFullProgramBuilder* builder,
-                          const GrDrawEffect& drawEffect,
+                          const GrEffect& effect,
                           const GrEffectKey& key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
-    static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+    static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
-    virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
 
 private:
     GrGLProgramDataManager::UniformHandle fRectUniform;
     GrGLProgramDataManager::UniformHandle fIntervalUniform;
     SkRect                                fPrevRect;
     SkScalar                              fPrevIntervalLength;
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 GLDashingLineEffect::GLDashingLineEffect(const GrBackendEffectFactory& factory,
-                                     const GrDrawEffect& drawEffect)
+                                     const GrEffect& effect)
     : INHERITED (factory) {
     fPrevRect.fLeft = SK_ScalarNaN;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingLineEffect::emitCode(GrGLFullProgramBuilder* builder,
-                                    const GrDrawEffect& drawEffect,
+                                    const GrEffect& effect,
                                     const GrEffectKey& key,
                                     const char* outputColor,
                                     const char* inputColor,
                                     const TransformedCoordsArray&,
                                     const TextureSamplerArray& samplers) {
-    const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
+    const DashingLineEffect& de = effect.cast<DashingLineEffect>();
     const char *rectName;
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                        kVec4f_GrSLType,
                                        "rect",
                                        &rectName);
     const char *intervalName;
     // The interval uniform's refers to the total length of the interval (on + off)
     fIntervalUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
@@ skipping 25 matching lines @@
     } else {
         // Assuming the bounding geometry is tight so no need to check y values
         fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n");
         fsBuilder->codeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ? 1.0 : 0.0;\n", rectName);
         fsBuilder->codeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ? 1.0 : 0.0;\n", rectName);
     }
     fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor,
                            (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
 }
 
-void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
-    const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
+void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
+    const DashingLineEffect& de = effect.cast<DashingLineEffect>();
     const SkRect& rect = de.getRect();
     SkScalar intervalLength = de.getIntervalLength();
     if (rect != fPrevRect || intervalLength != fPrevIntervalLength) {
         pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f,
                     rect.fRight - 0.5f, rect.fBottom - 0.5f);
         pdman.set1f(fIntervalUniform, intervalLength);
         fPrevRect = rect;
         fPrevIntervalLength = intervalLength;
     }
 }
 
-void GLDashingLineEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+void GLDashingLineEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
                                  GrEffectKeyBuilder* b) {
-    const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
+    const DashingLineEffect& de = effect.cast<DashingLineEffect>();
     b->add32(de.getEdgeType());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrEffect* DashingLineEffect::Create(GrEffectEdgeType edgeType, const DashInfo& info,
                                     SkScalar strokeWidth) {
     if (info.fCount != 2) {
         return NULL;
     }
@@ skipping 19 matching lines @@
                                                  GrShaderVar::kAttribute_TypeModifier))) {
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     SkScalar halfOffLen = SkScalarHalf(offLen);
     SkScalar halfStroke = SkScalarHalf(strokeWidth);
     fIntervalLength = onLen + offLen;
     fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke);
 }
 
 bool DashingLineEffect::onIsEqual(const GrEffect& other) const {
-    const DashingLineEffect& de = CastEffect<DashingLineEffect>(other);
+    const DashingLineEffect& de = other.cast<DashingLineEffect>();
     return (fEdgeType == de.fEdgeType &&
             fRect == de.fRect &&
             fIntervalLength == de.fIntervalLength);
 }
 
 GR_DEFINE_EFFECT_TEST(DashingLineEffect);
 
 GrEffect* DashingLineEffect::TestCreate(SkRandom* random,
                                         GrContext*,
                                         const GrDrawTargetCaps& caps,
@@ skipping 21 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }