removing GrDrawEffect

src/gpu/effects/GrRRectEffect.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 "GrRRectEffect.h"
 
@@ skipping 84 matching lines @@
 
 CircularRRectEffect::CircularRRectEffect(GrEffectEdgeType edgeType, uint32_t circularCornerFlags,
                          const SkRRect& rrect)
     : fRRect(rrect)
     , fEdgeType(edgeType)
     , fCircularCornerFlags(circularCornerFlags) {
     this->setWillReadFragmentPosition();
 }
 
 bool CircularRRectEffect::onIsEqual(const GrEffect& other) const {
-    const CircularRRectEffect& crre = CastEffect<CircularRRectEffect>(other);
+    const CircularRRectEffect& crre = other.cast<CircularRRectEffect>();
     // The corner flags are derived from fRRect, so no need to check them.
     return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(CircularRRectEffect);
 
 GrEffect* CircularRRectEffect::TestCreate(SkRandom* random,
                                           GrContext*,
                                           const GrDrawTargetCaps& caps,
                                           GrTexture*[]) {
     SkScalar w = random->nextRangeScalar(20.f, 1000.f);
     SkScalar h = random->nextRangeScalar(20.f, 1000.f);
     SkScalar r = random->nextRangeF(kRadiusMin, 9.f);
     SkRRect rrect;
     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
     GrEffect* effect;
     do {
         GrEffectEdgeType et = (GrEffectEdgeType)random->nextULessThan(kGrEffectEdgeTypeCnt);
         effect = GrRRectEffect::Create(et, rrect);
     } while (NULL == effect);
     return effect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLCircularRRectEffect : public GrGLEffect {
 public:
-    GLCircularRRectEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+    GLCircularRRectEffect(const GrBackendEffectFactory&, const GrEffect&);
 
     virtual void emitCode(GrGLProgramBuilder* 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 fInnerRectUniform;
     GrGLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
     SkRRect                               fPrevRRect;
     typedef GrGLEffect INHERITED;
 };
 
 GLCircularRRectEffect::GLCircularRRectEffect(const GrBackendEffectFactory& factory,
-                             const GrDrawEffect& drawEffect)
+                             const GrEffect& effect)
     : INHERITED (factory) {
     fPrevRRect.setEmpty();
 }
 
 void GLCircularRRectEffect::emitCode(GrGLProgramBuilder* builder,
-                             const GrDrawEffect& drawEffect,
+                             const GrEffect& effect,
                              const GrEffectKey& key,
                              const char* outputColor,
                              const char* inputColor,
                              const TransformedCoordsArray&,
                              const TextureSamplerArray& samplers) {
-    const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
+    const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
     const char *rectName;
     const char *radiusPlusHalfName;
     // The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
     // edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
     // only rectangular corners, that side's value corresponds to the rect edge's value outset by
     // half a pixel.
     fInnerRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
                                             "innerRect",
                                             &rectName);
@@ skipping 106 matching lines @@
     }
 
     if (kInverseFillAA_GrEffectEdgeType == crre.getEdgeType()) {
         fsBuilder->codeAppend("\t\talpha = 1.0 - alpha;\n");
     }
 
     fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor,
                            (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
 }
 
-void GLCircularRRectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+void GLCircularRRectEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
                                    GrEffectKeyBuilder* b) {
-    const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
+    const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
     GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
     b->add32((crre.getCircularCornerFlags() << 3) | crre.getEdgeType());
 }
 
 void GLCircularRRectEffect::setData(const GrGLProgramDataManager& pdman,
-                                    const GrDrawEffect& drawEffect) {
-    const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
+                                    const GrEffect& effect) {
+    const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
     const SkRRect& rrect = crre.getRRect();
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         SkScalar radius = 0;
         switch (crre.getCircularCornerFlags()) {
             case CircularRRectEffect::kAll_CornerFlags:
                 SkASSERT(rrect.isSimpleCircular());
                 radius = rrect.getSimpleRadii().fX;
                 SkASSERT(radius >= kRadiusMin);
                 rect.inset(radius, radius);
@@ skipping 113 matching lines @@
     return GrTBackendEffectFactory<EllipticalRRectEffect>::getInstance();
 }
 
 EllipticalRRectEffect::EllipticalRRectEffect(GrEffectEdgeType edgeType, const SkRRect& rrect)
     : fRRect(rrect)
     , fEdgeType(edgeType){
     this->setWillReadFragmentPosition();
 }
 
 bool EllipticalRRectEffect::onIsEqual(const GrEffect& other) const {
-    const EllipticalRRectEffect& erre = CastEffect<EllipticalRRectEffect>(other);
+    const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
     return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(EllipticalRRectEffect);
 
 GrEffect* EllipticalRRectEffect::TestCreate(SkRandom* random,
                                             GrContext*,
                                             const GrDrawTargetCaps& caps,
@@ skipping 29 matching lines @@
         GrEffectEdgeType et = (GrEffectEdgeType)random->nextULessThan(kGrEffectEdgeTypeCnt);
         effect = GrRRectEffect::Create(et, rrect);
     } while (NULL == effect);
     return effect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLEllipticalRRectEffect : public GrGLEffect {
 public:
-    GLEllipticalRRectEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+    GLEllipticalRRectEffect(const GrBackendEffectFactory&, const GrEffect&);
 
     virtual void emitCode(GrGLProgramBuilder* 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 fInnerRectUniform;
     GrGLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
     SkRRect                               fPrevRRect;
     typedef GrGLEffect INHERITED;
 };
 
 GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrBackendEffectFactory& factory,
-                             const GrDrawEffect& drawEffect)
+                             const GrEffect& effect)
     : INHERITED (factory) {
     fPrevRRect.setEmpty();
 }
 
 void GLEllipticalRRectEffect::emitCode(GrGLProgramBuilder* builder,
-                                       const GrDrawEffect& drawEffect,
+                                       const GrEffect& effect,
                                        const GrEffectKey& key,
                                        const char* outputColor,
                                        const char* inputColor,
                                        const TransformedCoordsArray&,
                                        const TextureSamplerArray& samplers) {
-    const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
+    const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
     const char *rectName;
     // The inner rect is the rrect bounds inset by the x/y radii
     fInnerRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
                                             "innerRect",
                                             &rectName);
 
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     const char* fragmentPos = fsBuilder->fragmentPosition();
     // At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
@@ skipping 49 matching lines @@
     if (kFillAA_GrEffectEdgeType == erre.getEdgeType()) {
         fsBuilder->codeAppend("\t\tfloat alpha = clamp(0.5 - approx_dist, 0.0, 1.0);\n");
     } else {
         fsBuilder->codeAppend("\t\tfloat alpha = clamp(0.5 + approx_dist, 0.0, 1.0);\n");
     }
 
     fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor,
                            (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
 }
 
-void GLEllipticalRRectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+void GLEllipticalRRectEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
                                      GrEffectKeyBuilder* b) {
-    const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
+    const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
     GR_STATIC_ASSERT(kLast_GrEffectEdgeType < (1 << 3));
     b->add32(erre.getRRect().getType() | erre.getEdgeType() << 3);
 }
 
 void GLEllipticalRRectEffect::setData(const GrGLProgramDataManager& pdman,
-                                      const GrDrawEffect& drawEffect) {
-    const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
+                                      const GrEffect& effect) {
+    const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
     const SkRRect& rrect = erre.getRRect();
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
         SkASSERT(r0.fX >= kRadiusMin);
         SkASSERT(r0.fY >= kRadiusMin);
         switch (erre.getRRect().getType()) {
             case SkRRect::kSimple_Type:
                 rect.inset(r0.fX, r0.fY);
                 pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
@@ skipping 112 matching lines @@
                 if (rrect.isNinePatch()) {
                     return EllipticalRRectEffect::Create(edgeType, rrect);
                 }
                 return NULL;
             }
         }
     }
 
     return NULL;
 }