Solo gp

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
@@ skipping 280 matching lines @@
 
 static inline int next_dither_toggle16(int toggle) {
     return toggle ^ SkGradientShaderBase::kDitherStride16;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
-#include "gl/GrGLEffect.h"
+#include "gl/GrGLProcessor.h"
 
-class GrEffectStage;
-class GrBackendEffectFactory;
+class GrProcessorStage;
+class GrBackendProcessorFactory;
 
 /*
  * The interpretation of the texture matrix depends on the sample mode. The
  * texture matrix is applied both when the texture coordinates are explicit
  * and  when vertex positions are used as texture  coordinates. In the latter
  * case the texture matrix is applied to the pre-view-matrix position
  * values.
  *
  * Normal SampleMode
  *  The post-matrix texture coordinates are in normalize space with (0,0) at
  *  the top-left and (1,1) at the bottom right.
  * RadialGradient
  *  The matrix specifies the radial gradient parameters.
  *  (0,0) in the post-matrix space is center of the radial gradient.
  * Radial2Gradient
  *   Matrix transforms to space where first circle is centered at the
  *   origin. The second circle will be centered (x, 0) where x may be
  *   0 and is provided by setRadial2Params. The post-matrix space is
  *   normalized such that 1 is the second radius - first radius.
  * SweepGradient
  *  The angle from the origin of texture coordinates in post-matrix space
  *  determines the gradient value.
  */
 
  class GrTextureStripAtlas;
 
 // Base class for Gr gradient effects
-class GrGradientEffect : public GrEffect {
+class GrGradientEffect : public GrFragmentProcessor {
 public:
 
     GrGradientEffect(GrContext* ctx,
                      const SkGradientShaderBase& shader,
                      const SkMatrix& matrix,
                      SkShader::TileMode tileMode);
 
     virtual ~GrGradientEffect();
 
     bool useAtlas() const { return SkToBool(-1 != fRow); }
@@ skipping 24 matching lines @@
         sized to be at least kMaxRandomGradientColors. stops is a pointer to an array of at least
         size kMaxRandomGradientColors. It may be updated to NULL, indicating that NULL should be
         passed to the gradient factory rather than the array.
     */
     static const int kMaxRandomGradientColors = 4;
     static int RandomGradientParams(SkRandom* r,
                                     SkColor colors[kMaxRandomGradientColors],
                                     SkScalar** stops,
                                     SkShader::TileMode* tm);
 
-    virtual bool onIsEqual(const GrEffect& effect) const SK_OVERRIDE;
+    virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
 
     const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
 
 private:
     static const GrCoordSet kCoordSet = kLocal_GrCoordSet;
 
     GrCoordTransform fCoordTransform;
     GrTextureAccess fTextureAccess;
     SkScalar fYCoord;
     GrTextureStripAtlas* fAtlas;
     int fRow;
     bool fIsOpaque;
     SkGradientShaderBase::GpuColorType fColorType;
     SkColor fColors[3]; // More than 3 colors we use texture
     PremulType fPremulType; // This only changes behavior for two and three color special cases.
                             // It is already baked into to the table for texture gradients.
-    typedef GrEffect INHERITED;
+    typedef GrFragmentProcessor INHERITED;
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Base class for GL gradient effects
-class GrGLGradientEffect : public GrGLEffect {
+class GrGLGradientEffect : public GrGLFragmentProcessor {
 public:
-    GrGLGradientEffect(const GrBackendEffectFactory& factory);
+    GrGLGradientEffect(const GrBackendProcessorFactory& factory);
     virtual ~GrGLGradientEffect();
 
-    virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
 
 protected:
     /**
      * Subclasses must call this. It will return a key for the part of the shader code controlled
      * by the base class. The subclasses must stick it in their key and then pass it to the below
      * emit* functions from their emitCode function.
      */
-    static uint32_t GenBaseGradientKey(const GrEffect&);
+    static uint32_t GenBaseGradientKey(const GrProcessor&);
 
     // Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses
     // should call this method from their emitCode().
     void emitUniforms(GrGLProgramBuilder* builder, uint32_t baseKey);
 
 
     // emit code that gets a fragment's color from an expression for t; Has branches for 3 separate
     // control flows inside -- 2 color gradients, 3 color symmetric gradients (both using
     // native GLSL mix), and 4+ color gradients that use the traditional texture lookup.
     void emitColor(GrGLProgramBuilder* builder,
@@ skipping 35 matching lines @@
             return GrGradientEffect::kAfterInterp_PremulType;
         }
     }
 
     SkScalar fCachedYCoord;
     GrGLProgramDataManager::UniformHandle fFSYUni;
     GrGLProgramDataManager::UniformHandle fColorStartUni;
     GrGLProgramDataManager::UniformHandle fColorMidUni;
     GrGLProgramDataManager::UniformHandle fColorEndUni;
 
-    typedef GrGLEffect INHERITED;
+    typedef GrGLFragmentProcessor INHERITED;
 };
 
 #endif
 
 #endif