Make GPU coord transforms automatic

src/effects/SkBitmapAlphaThresholdShader.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapAlphaThresholdShader.h"
 
 class BATShader : public SkShader {
@@ skipping 44 matching lines @@
     fBitmap.toString(str);
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
+#include "GrCoordTransform.h"
 #include "GrEffect.h"
 #include "gl/GrGLEffect.h"
-#include "gl/GrGLEffectMatrix.h"
 #include "GrTBackendEffectFactory.h"
 #include "GrTextureAccess.h"
 
 #include "SkGr.h"
 
 /**
  * Could create specializations for some simple cases:
  *  - The region is empty.
  *  - The region fully contains the bitmap.
  *  - The regions is 1 rect (or maybe a small number of rects).
@@ skipping 24 matching lines @@
         return;
     }
 
     static const char* Name() { return "Bitmap Alpha Threshold"; }
 
     class GLEffect : public GrGLEffect {
     public:
         GLEffect(const GrBackendEffectFactory& factory,
                     const GrDrawEffect& e)
         : GrGLEffect(factory)
-        , fBmpMatrix(GrEffect::kLocal_CoordsType)
-        , fMaskMatrix(GrEffect::kLocal_CoordsType)
         , fPrevThreshold(-SK_Scalar1) {
         }
 
         virtual void emitCode(GrGLShaderBuilder* builder,
-                                const GrDrawEffect& drawEffect,
-                                EffectKey key,
-                                const char* outputColor,
-                                const char* inputColor,
-                                const TextureSamplerArray& samplers) SK_OVERRIDE {
-            SkString bmpCoord;
-            SkString maskCoord;
-
-            GrSLType bmpCoordType = fBmpMatrix.emitCode(builder, key, &bmpCoord, NULL, "Bmp");
-            EffectKey maskMatrixKey = key >> GrGLEffectMatrix::kKeyBits;
-            GrSLType maskCoordType = fMaskMatrix.emitCode(builder,
-                                                          maskMatrixKey,
-                                                          &maskCoord,
-                                                          NULL,
-                                                          "Mask");
-
+                              const GrDrawEffect& drawEffect,
+                              EffectKey key,
+                              const char* outputColor,
+                              const char* inputColor,
+                              const TransformedCoordsArray& coords,
+                              const TextureSamplerArray& samplers) SK_OVERRIDE {
             // put bitmap color in "color"
             builder->fsCodeAppend("\t\tvec4 color = ");
-            builder->fsAppendTextureLookup(samplers[0], bmpCoord.c_str(), bmpCoordType);
+            builder->fsAppendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type());
             builder->fsCodeAppend(";\n");
 
             // put alpha from mask texture in "mask"
             builder->fsCodeAppend("\t\tfloat mask = ");
-            builder->fsAppendTextureLookup(samplers[1], maskCoord.c_str(), maskCoordType);
+            builder->fsAppendTextureLookup(samplers[1], coords[1].c_str(), coords[1].type());
             builder->fsCodeAppend(".a;\n");
 
             const char* threshold;
 
             fThresholdUniHandle = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                       kFloat_GrSLType,
                                                       "threshold",
                                                       &threshold);
             builder->fsCodeAppendf("\t\tfloat thresh = %s;\n", threshold);
 
@@ skipping 12 matching lines @@
             builder->fsCodeAppend("color = ");
             SkString outStr;
             outStr.appendf("\t\t%s = ", outputColor);
             GrGLSLModulatef<4>(&outStr, inputColor, "color");
             outStr.append(";\n");
             builder->fsCodeAppend(outStr.c_str());
         }
 
         virtual void setData(const GrGLUniformManager& uman, const GrDrawEffect& e) SK_OVERRIDE {
             const ThresholdEffect& effect = e.castEffect<ThresholdEffect>();
-            fBmpMatrix.setData(uman, effect.fBmpMatrix, e, effect.fBmpAccess.getTexture());
-            fMaskMatrix.setData(uman, effect.fMaskMatrix, e, effect.fMaskAccess.getTexture());
             if (fPrevThreshold != effect.fThreshold) {
                 uman.set1f(fThresholdUniHandle, effect.fThreshold);
             }
         }
 
-        static inline EffectKey GenKey(const GrDrawEffect& e, const GrGLCaps&) {
-            const ThresholdEffect& effect = e.castEffect<ThresholdEffect>();
-
-            EffectKey bmpMKey = GrGLEffectMatrix::GenKey(effect.fBmpMatrix,
-                                                         e,
-                                                         GrEffect::kLocal_CoordsType,
-                                                         effect.fBmpAccess.getTexture());
-            EffectKey maskMKey = GrGLEffectMatrix::GenKey(effect.fMaskMatrix,
-                                                          e,
-                                                          GrEffect::kLocal_CoordsType,
-                                                          effect.fMaskAccess.getTexture());
-            return bmpMKey | (maskMKey << GrGLEffectMatrix::kKeyBits);
-        }
-
     private:
-        GrGLEffectMatrix fBmpMatrix;
-        GrGLEffectMatrix fMaskMatrix;
-
         GrGLUniformManager::UniformHandle fThresholdUniHandle;
         SkScalar                          fPrevThreshold;
     };
 
     GR_DECLARE_EFFECT_TEST;
 
 private:
     ThresholdEffect(GrTexture* bmpTexture, const SkMatrix& bmpMatrix,
                     GrTexture* maskTexture, const SkMatrix& maskMatrix,
                     SkScalar threshold)
-    : fBmpAccess(bmpTexture, GrTextureParams())
+    : fBmpTransform(kLocal_GrCoordSet, bmpMatrix, bmpTexture)
+    , fBmpAccess(bmpTexture, GrTextureParams())
+    , fMaskTransform(kLocal_GrCoordSet, maskMatrix, maskTexture)
     , fMaskAccess(maskTexture, GrTextureParams())
-    , fBmpMatrix(bmpMatrix)
-    , fMaskMatrix(maskMatrix)
     , fThreshold(threshold) {
+        this->addCoordTransform(&fBmpTransform);
         this->addTextureAccess(&fBmpAccess);
+        this->addCoordTransform(&fMaskTransform);
         this->addTextureAccess(&fMaskAccess);
     }
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
         const ThresholdEffect& e = CastEffect<ThresholdEffect>(other);
         return e.fBmpAccess.getTexture() == fBmpAccess.getTexture() &&
                e.fMaskAccess.getTexture() == fMaskAccess.getTexture() &&
-               e.fBmpMatrix == fBmpMatrix &&
-               e.fMaskMatrix == fMaskMatrix &&
+               e.fBmpTransform.getMatrix() == fBmpTransform.getMatrix() &&
+               e.fMaskTransform.getMatrix() == fMaskTransform.getMatrix() &&
                e.fThreshold == fThreshold;
     }
 
-    GrTextureAccess fBmpAccess;
-    GrTextureAccess fMaskAccess;
-
-    SkMatrix fBmpMatrix;
-    SkMatrix fMaskMatrix;
+    GrCoordTransform fBmpTransform;
+    GrTextureAccess  fBmpAccess;
+    GrCoordTransform fMaskTransform;
+    GrTextureAccess  fMaskAccess;
 
     SkScalar fThreshold;
 };
 
 GR_DEFINE_EFFECT_TEST(ThresholdEffect);
 
 GrEffectRef* ThresholdEffect::TestCreate(SkRandom* rand,
                                          GrContext*,
                                          const GrDrawTargetCaps&,
                                          GrTexture* textures[]) {
@@ skipping 60 matching lines @@
     GrEffectRef* effect = ThresholdEffect::Create(bmpTexture, bmpMatrix,
                                                   maskTexture, maskMatrix,
                                                   fThreshold);
 
     GrUnlockAndUnrefCachedBitmapTexture(bmpTexture);
 
     return effect;
 }
 
 #endif