Make GPU coord transforms automatic

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 185 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/GrGLEffectMatrix.h"
 
 class GrEffectStage;
 class GrBackendEffectFactory;
 
 /*
  * 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.
@@ skipping 22 matching lines @@
 
     GrGradientEffect(GrContext* ctx,
                      const SkGradientShaderBase& shader,
                      const SkMatrix& matrix,
                      SkShader::TileMode tileMode);
 
     virtual ~GrGradientEffect();
 
     bool useAtlas() const { return SkToBool(-1 != fRow); }
     SkScalar getYCoord() const { return fYCoord; };
-    const SkMatrix& getMatrix() const { return fMatrix;}
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
     enum ColorType {
         kTwo_ColorType,
         kThree_ColorType,
         kTexture_ColorType
     };
 
     ColorType getColorType() const { return fColorType; }
@@ skipping 22 matching lines @@
     */
     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;
 
 private:
+    static const GrCoordSet kCoordSet = kLocal_GrCoordSet;
 
     enum {
         kMaxAnalyticColors = 3 // if more colors use texture
     };
 
+    GrCoordTransform fCoordTransform;
     GrTextureAccess fTextureAccess;
     SkScalar fYCoord;
     GrTextureStripAtlas* fAtlas;
     int fRow;
-    SkMatrix fMatrix;
     bool fIsOpaque;
     ColorType fColorType;
     SkColor fColors[kMaxAnalyticColors];
     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;
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Base class for GL gradient effects
 class GrGLGradientEffect : public GrGLEffect {
 public:
     GrGLGradientEffect(const GrBackendEffectFactory& factory);
     virtual ~GrGLGradientEffect();
 
     virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
 
 protected:
-    /**
-     * Subclasses must reserve the lower kMatrixKeyBitCnt of their key for use by
-     * GrGLGradientEffect.
-     */
     enum {
-        kMatrixKeyBitCnt = GrGLEffectMatrix::kKeyBits,
-        kMatrixKeyMask = (1 << kMatrixKeyBitCnt) - 1,
-
         kPremulTypeKeyBitCnt = 1,
-        kPremulTypeMask = 1 << kMatrixKeyBitCnt,
+        kPremulTypeMask = 1,
         kPremulBeforeInterpKey = kPremulTypeMask,
 
-        kTwoColorKey = 2 << (kMatrixKeyBitCnt + kPremulTypeKeyBitCnt),
-        kThreeColorKey = 3 << (kMatrixKeyBitCnt + kPremulTypeKeyBitCnt),
+        kTwoColorKey = 2 << kPremulTypeKeyBitCnt,
+        kThreeColorKey = 3 << kPremulTypeKeyBitCnt,
         kColorKeyMask = kTwoColorKey | kThreeColorKey,
         kColorKeyBitCnt = 2,
 
         // Subclasses must shift any key bits they produce up by this amount
         // and combine with the result of GenBaseGradientKey.
-        kBaseKeyBitCnt = (kMatrixKeyBitCnt + kPremulTypeKeyBitCnt + kColorKeyBitCnt)
+        kBaseKeyBitCnt = (kPremulTypeKeyBitCnt + kColorKeyBitCnt)
     };
 
     static GrGradientEffect::ColorType ColorTypeFromKey(EffectKey key){
         if (kTwoColorKey == (key & kColorKeyMask)) {
             return GrGradientEffect::kTwo_ColorType;
         } else if (kThreeColorKey == (key & kColorKeyMask)) {
             return GrGradientEffect::kThree_ColorType;
         } else {return GrGradientEffect::kTexture_ColorType;}
     }
 
     static GrGradientEffect::PremulType PremulTypeFromKey(EffectKey key){
         if (kPremulBeforeInterpKey == (key & kPremulTypeMask)) {
             return GrGradientEffect::kBeforeInterp_PremulType;
         } else {
             return GrGradientEffect::kAfterInterp_PremulType;
         }
     }
 
     /**
      * Subclasses must call this. It will return a value restricted to the lower kBaseKeyBitCnt
      * bits.
      */
     static EffectKey GenBaseGradientKey(const GrDrawEffect&);
 
-    /**
-     * Inserts code to implement the GrGradientEffect's matrix. This should be called before a
-     * subclass emits its own code. The name of the 2D coords is output via fsCoordName and already
-     * incorporates any perspective division. The caller can also optionally retrieve the name of
-     * the varying inserted in the VS and its type, which may be either vec2f or vec3f depending
-     * upon whether the matrix has perspective or not. It is not necessary to mask the key before
-     * calling.
-     */
-    void setupMatrix(GrGLShaderBuilder* builder,
-                     EffectKey key,
-                     SkString* fsCoordName,
-                     SkString* vsVaryingName = NULL,
-                     GrSLType* vsVaryingType = NULL);
-
     // Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses
     // should call this method from their emitCode().
     void emitUniforms(GrGLShaderBuilder* builder, EffectKey key);
 
 
     // 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(GrGLShaderBuilder* builder,
                    const char* gradientTValue,
                    EffectKey key,
                    const char* outputColor,
                    const char* inputColor,
                    const GrGLShaderBuilder::TextureSamplerArray& samplers);
 
 private:
-    static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;
-
     SkScalar fCachedYCoord;
     GrGLUniformManager::UniformHandle fFSYUni;
     GrGLUniformManager::UniformHandle fColorStartUni;
     GrGLUniformManager::UniformHandle fColorMidUni;
     GrGLUniformManager::UniformHandle fColorEndUni;
-    GrGLEffectMatrix fEffectMatrix;
 
     typedef GrGLEffect INHERITED;
 };
 
 #endif
 
 #endif