Reland r6233 with fix.

git-svn-id: http://skia.googlecode.com/svn/trunk@6241 2bbb7eff-a529-9590-31e7-b0007b416f81

4 files changed, 83 insertions, 22 deletions

diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 086064545e..54d7285c93 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -218,21 +218,27 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
     }
 }
 
-GrEffect* GrConfigConversionEffect::Create(GrTexture* texture,
-                                                bool swapRedAndBlue,
-                                                PMConversion pmConversion) {
+bool GrConfigConversionEffect::InstallEffect(GrTexture* texture,
+                                             bool swapRedAndBlue,
+                                             PMConversion pmConversion,
+                                             const GrMatrix& matrix,
+                                             GrEffectStage* stage) {
     if (!swapRedAndBlue && kNone_PMConversion == pmConversion) {
         // If we returned a GrConfigConversionEffect that was equivalent to a GrSingleTextureEffect
         // then we may pollute our texture cache with redundant shaders. So in the case that no
         // conversions were requested we instead return a GrSingleTextureEffect.
-        return SkNEW_ARGS(GrSingleTextureEffect, (texture));
+        stage->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix)), matrix)->unref();
+        return true;
     } else {
         if (kRGBA_8888_GrPixelConfig != texture->config() &&
             kBGRA_8888_GrPixelConfig != texture->config() &&
             kNone_PMConversion != pmConversion) {
             // The PM conversions assume colors are 0..255
-            return NULL;
+            return false;
         }
-        return SkNEW_ARGS(GrConfigConversionEffect, (texture, swapRedAndBlue, pmConversion));
+        stage->setEffect(SkNEW_ARGS(GrConfigConversionEffect, (texture,
+                                                               swapRedAndBlue,
+                                                               pmConversion)), matrix)->unref();
+        return true;
     }
 }
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index 7c5f03fa2b..5b531d4d58 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -33,10 +33,12 @@ public:
         kPMConversionCnt
     };
 
-    // This will fail if the config is not 8888 and a PM conversion is requested.
-    static GrEffect* Create(GrTexture*,
-                                 bool swapRedAndBlue,
-                                 PMConversion pmConversion = kNone_PMConversion);
+    // Installs an effect in the GrEffectStage to perform a config conversion.
+    static bool InstallEffect(GrTexture*,
+                              bool swapRedAndBlue,
+                              PMConversion pmConversion,
+                              const GrMatrix& matrix,
+                              GrEffectStage* stage);
 
     static const char* Name() { return "Config Conversion"; }
     typedef GrGLConfigConversionEffect GLEffect;
diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp
index 8866153962..0f3b614dd7 100644
--- a/src/gpu/effects/GrSingleTextureEffect.cpp
+++ b/src/gpu/effects/GrSingleTextureEffect.cpp
@@ -7,6 +7,7 @@
 
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLEffect.h"
+#include "gl/GrGLEffectMatrix.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLTexture.h"
 #include "GrTBackendEffectFactory.h"
@@ -16,25 +17,43 @@ class GrGLSingleTextureEffect : public GrGLEffect {
 public:
     GrGLSingleTextureEffect(const GrBackendEffectFactory& factory, const GrEffect&)
     : INHERITED (factory) {
+        fRequiresTextureMatrix = false;
     }
 
     virtual void emitCode(GrGLShaderBuilder* builder,
                           const GrEffectStage&,
-                          EffectKey,
+                          EffectKey key,
                           const char* vertexCoords,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray& samplers) SK_OVERRIDE {
-
+        const char* coordName;
+        GrSLType coordType = fEffectMatrix.emitCode(builder, key, vertexCoords, &coordName);
         builder->fFSCode.appendf("\t%s = ", outputColor);
-        builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplers[0]);
+        builder->appendTextureLookupAndModulate(&builder->fFSCode,
+                                                inputColor,
+                                                samplers[0],
+                                                coordName,
+                                                coordType);
         builder->fFSCode.append(";\n");
     }
 
-    static inline EffectKey GenKey(const GrEffectStage&, const GrGLCaps&) { return 0; }
+    static inline EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) {
+        const GrSingleTextureEffect& ste =
+            static_cast<const GrSingleTextureEffect&>(*stage.getEffect());
+        return GrGLEffectMatrix::GenKey(ste.getMatrix(),
+                                        stage.getCoordChangeMatrix(),
+                                        ste.texture(0));
+    }
 
-private:
+    virtual void setData(const GrGLUniformManager& uman, const GrEffectStage& stage) SK_OVERRIDE {
+        const GrSingleTextureEffect& ste =
+            static_cast<const GrSingleTextureEffect&>(*stage.getEffect());
+        fEffectMatrix.setData(uman, ste.getMatrix(), stage.getCoordChangeMatrix(), ste.texture(0));
+    }
 
+private:
+    GrGLEffectMatrix fEffectMatrix;
     typedef GrGLEffect INHERITED;
 };
 
@@ -43,16 +62,39 @@ private:
 GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture)
     : INHERITED(1)
     , fTextureAccess(texture) {
+    fMatrix.reset();
 }
 
 GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, bool bilerp)
     : INHERITED(1)
     , fTextureAccess(texture, bilerp) {
+    fMatrix.reset();
 }
 
 GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrTextureParams& params)
     : INHERITED(1)
     , fTextureAccess(texture, params) {
+    fMatrix.reset();
+}
+
+GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrMatrix& m)
+    : INHERITED(1)
+    , fTextureAccess(texture)
+    , fMatrix(m) {
+}
+
+GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrMatrix& m, bool bilerp)
+    : INHERITED(1)
+    , fTextureAccess(texture, bilerp)
+    , fMatrix(m) {
+}
+
+GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
+                                             const GrMatrix& m,
+                                             const GrTextureParams& params)
+    : INHERITED(1)
+    , fTextureAccess(texture, params)
+    , fMatrix(m) {
 }
 
 GrSingleTextureEffect::~GrSingleTextureEffect() {
@@ -76,5 +118,6 @@ GrEffect* GrSingleTextureEffect::TestCreate(SkRandom* random,
                                             GrTexture* textures[]) {
     int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
                                       GrEffectUnitTest::kAlphaTextureIdx;
-    return SkNEW_ARGS(GrSingleTextureEffect, (textures[texIdx]));
+    const SkMatrix& matrix = GrEffectUnitTest::TestMatrix(random);
+    return SkNEW_ARGS(GrSingleTextureEffect, (textures[texIdx], matrix));
 }
diff --git a/src/gpu/effects/GrSingleTextureEffect.h b/src/gpu/effects/GrSingleTextureEffect.h
index 346a6f48d8..23b416d3b3 100644
--- a/src/gpu/effects/GrSingleTextureEffect.h
+++ b/src/gpu/effects/GrSingleTextureEffect.h
@@ -9,6 +9,7 @@
 #define GrSingleTextureEffect_DEFINED
 
 #include "GrEffect.h"
+#include "GrMatrix.h"
 
 class GrGLSingleTextureEffect;
 
@@ -18,28 +19,37 @@ class GrGLSingleTextureEffect;
 class GrSingleTextureEffect : public GrEffect {
 
 public:
-    /** Uses default texture params (unfiltered, clamp) */
-    GrSingleTextureEffect(GrTexture* texture);
-
-    /** Uses default tile mode (clamp) */
-    GrSingleTextureEffect(GrTexture* texture, bool bilerp);
-
+    /** These three constructors assume an identity matrix */
+    GrSingleTextureEffect(GrTexture* texture); /* unfiltered, clamp mode */
+    GrSingleTextureEffect(GrTexture* texture, bool bilerp); /* clamp mode */
     GrSingleTextureEffect(GrTexture* texture, const GrTextureParams&);
 
+    /** These three constructors take an explicit matrix */
+    GrSingleTextureEffect(GrTexture*, const GrMatrix&); /* unfiltered, clamp mode */
+    GrSingleTextureEffect(GrTexture*, const GrMatrix&, bool bilerp); /* clamp mode */
+    GrSingleTextureEffect(GrTexture*, const GrMatrix&, const GrTextureParams&);
+
     virtual ~GrSingleTextureEffect();
 
     virtual const GrTextureAccess& textureAccess(int index) const SK_OVERRIDE;
 
     static const char* Name() { return "Single Texture"; }
 
+    const GrMatrix& getMatrix() const { return fMatrix; }
+
     typedef GrGLSingleTextureEffect GLEffect;
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
 
+    virtual bool isEqual(const GrEffect& effect) const SK_OVERRIDE {
+        const GrSingleTextureEffect& ste = static_cast<const GrSingleTextureEffect&>(effect);
+        return INHERITED::isEqual(effect) && fMatrix.cheapEqualTo(ste.getMatrix());
+    }
 private:
     GR_DECLARE_EFFECT_TEST;
 
     GrTextureAccess fTextureAccess;
+    GrMatrix        fMatrix;
 
     typedef GrEffect INHERITED;
 };