Make GPU coord transforms automatic

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkXfermode.h"
@@ skipping 877 matching lines @@
 void SkProcXfermode::toString(SkString* str) const {
     str->appendf("SkProcXfermode: %p", fProc);
 }
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrEffect.h"
+#include "GrCoordTransform.h"
 #include "GrEffectUnitTest.h"
 #include "GrTBackendEffectFactory.h"
 #include "gl/GrGLEffect.h"
-#include "gl/GrGLEffectMatrix.h"
 
 /**
  * GrEffect that implements the all the separable xfer modes that cannot be expressed as Coeffs.
  */
 class XferEffect : public GrEffect {
 public:
     static bool IsSupportedMode(SkXfermode::Mode mode) {
         return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
     }
 
@@ skipping 16 matching lines @@
     }
 
     static const char* Name() { return "XferEffect"; }
 
     SkXfermode::Mode mode() const { return fMode; }
     const GrTextureAccess&  backgroundAccess() const { return fBackgroundAccess; }
 
     class GLEffect : public GrGLEffect {
     public:
         GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
-            : GrGLEffect(factory )
-            , fBackgroundEffectMatrix(kCoordsType) {
+            : GrGLEffect(factory) {
         }
         virtual void emitCode(GrGLShaderBuilder* builder,
                               const GrDrawEffect& drawEffect,
                               EffectKey key,
                               const char* outputColor,
                               const char* inputColor,
+                              const TransformedCoordsArray& coords,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             SkXfermode::Mode mode = drawEffect.castEffect<XferEffect>().mode();
             const GrTexture* backgroundTex = drawEffect.castEffect<XferEffect>().backgroundAccess().getTexture();
             const char* dstColor;
             if (backgroundTex) {
-                SkString bgCoords;
-                GrSLType bgCoordsType = fBackgroundEffectMatrix.emitCode(builder, key, &bgCoords, NULL, "BG");
                 dstColor = "bgColor";
                 builder->fsCodeAppendf("\t\tvec4 %s = ", dstColor);
-                builder->fsAppendTextureLookup(samplers[0], bgCoords.c_str(), bgCoordsType);
+                builder->fsAppendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type());
                 builder->fsCodeAppendf(";\n");
             } else {
                 dstColor = builder->dstColor();
             }
             SkASSERT(NULL != dstColor);
 
             // We don't try to optimize for this case at all
             if (NULL == inputColor) {
                 builder->fsCodeAppendf("\t\tconst vec4 ones = %s;\n", GrGLSLOnesVecf(4));
                 inputColor = "ones";
@@ skipping 115 matching lines @@
                                            outputColor, inputColor, dstColor, dstColor, inputColor);
                     break;
                 }
                 default:
                     GrCrash("Unknown XferEffect mode.");
                     break;
             }
         }
 
         static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
-            const XferEffect& xfer = drawEffect.castEffect<XferEffect>();
-            GrTexture* bgTex = xfer.backgroundAccess().getTexture();
-            EffectKey bgKey = 0;
-            if (bgTex) {
-                bgKey = GrGLEffectMatrix::GenKey(GrEffect::MakeDivByTextureWHMatrix(bgTex),
-                                                 drawEffect,
-                                                 GLEffect::kCoordsType,
-                                                 bgTex);
-            }
-            EffectKey modeKey = xfer.mode() << GrGLEffectMatrix::kKeyBits;
-            return modeKey | bgKey;
-        }
-
-        virtual void setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) SK_OVERRIDE {
-            const XferEffect& xfer = drawEffect.castEffect<XferEffect>();
-            GrTexture* bgTex = xfer.backgroundAccess().getTexture();
-            if (bgTex) {
-                fBackgroundEffectMatrix.setData(uman,
-                                                GrEffect::MakeDivByTextureWHMatrix(bgTex),
-                                                drawEffect,
-                                                bgTex);
-            }
+            return drawEffect.castEffect<XferEffect>().mode();
         }
 
     private:
         static void HardLight(GrGLShaderBuilder* builder,
                               const char* final,
                               const char* src,
                               const char* dst) {
             static const char kComponents[] = {'r', 'g', 'b'};
             for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) {
                 char component = kComponents[i];
@@ skipping 199 matching lines @@
                                getFunction.c_str(), helpFunc, helpFunc, helpFunc, helpFunc,
                                helpFunc, helpFunc);
             builder->fsEmitFunction(kVec3f_GrSLType,
                                     "set_saturation",
                                     SK_ARRAY_COUNT(setSatArgs), setSatArgs,
                                     setSatBody.c_str(),
                                     setSatFunction);
 
         }
 
-        static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;
-        GrGLEffectMatrix   fBackgroundEffectMatrix;
         typedef GrGLEffect INHERITED;
     };
 
     GR_DECLARE_EFFECT_TEST;
 
 private:
     XferEffect(SkXfermode::Mode mode, GrTexture* background)
         : fMode(mode) {
         if (background) {
+            fBackgroundTransform.reset(kLocal_GrCoordSet, background);
+            this->addCoordTransform(&fBackgroundTransform);
             fBackgroundAccess.reset(background);
             this->addTextureAccess(&fBackgroundAccess);
         } else {
             this->setWillReadDstColor();
         }
     }
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
         const XferEffect& s = CastEffect<XferEffect>(other);
         return fMode == s.fMode &&
                fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture();
     }
 
     SkXfermode::Mode fMode;
+    GrCoordTransform fBackgroundTransform;
     GrTextureAccess  fBackgroundAccess;
 
     typedef GrEffect INHERITED;
 };
 
 GR_DEFINE_EFFECT_TEST(XferEffect);
 GrEffectRef* XferEffect::TestCreate(SkRandom* rand,
                                     GrContext*,
                                     const GrDrawTargetCaps&,
                                     GrTexture*[]) {
@@ skipping 597 matching lines @@
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkClearXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSrcXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstInXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstOutXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END