Make GPU coord transforms automatic

src/effects/gradients/SkGradientShader.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 "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
@@ skipping 807 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "effects/GrTextureStripAtlas.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkGr.h"
 
 GrGLGradientEffect::GrGLGradientEffect(const GrBackendEffectFactory& factory)
     : INHERITED(factory)
-    , fCachedYCoord(SK_ScalarMax)
-    , fEffectMatrix(kCoordsType) {
+    , fCachedYCoord(SK_ScalarMax) {
 }
 
 GrGLGradientEffect::~GrGLGradientEffect() { }
 
 void GrGLGradientEffect::emitUniforms(GrGLShaderBuilder* builder, EffectKey key) {
 
     if (GrGradientEffect::kTwo_ColorType == ColorTypeFromKey(key)) { // 2 Color case
         fColorStartUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                              kVec4f_GrSLType, "GradientStartColor");
         fColorEndUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
@@ skipping 36 matching lines @@
 }
 
 void GrGLGradientEffect::setData(const GrGLUniformManager& uman,
                                  const GrDrawEffect& drawEffect) {
 
     const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>();
 
 
     if (GrGradientEffect::kTwo_ColorType == e.getColorType()){
 
-        fEffectMatrix.setData(uman, e.getMatrix(), drawEffect, NULL);
         if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
             set_mul_color_uni(uman, fColorStartUni, e.getColors(0));
             set_mul_color_uni(uman, fColorEndUni,   e.getColors(1));
         } else {
             set_color_uni(uman, fColorStartUni, e.getColors(0));
             set_color_uni(uman, fColorEndUni,   e.getColors(1));
         }
 
     } else if (GrGradientEffect::kThree_ColorType == e.getColorType()){
 
-        fEffectMatrix.setData(uman, e.getMatrix(), drawEffect, NULL);
         if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
             set_mul_color_uni(uman, fColorStartUni, e.getColors(0));
             set_mul_color_uni(uman, fColorMidUni,   e.getColors(1));
             set_mul_color_uni(uman, fColorEndUni,   e.getColors(2));
         } else {
             set_color_uni(uman, fColorStartUni, e.getColors(0));
             set_color_uni(uman, fColorMidUni,   e.getColors(1));
             set_color_uni(uman, fColorEndUni,   e.getColors(2));
         }
     } else {
-        const GrTexture* texture = e.texture(0);
-        fEffectMatrix.setData(uman, e.getMatrix(), drawEffect, texture);
 
         SkScalar yCoord = e.getYCoord();
         if (yCoord != fCachedYCoord) {
             uman.set1f(fFSYUni, yCoord);
             fCachedYCoord = yCoord;
         }
     }
 }
 
 
 GrGLEffect::EffectKey GrGLGradientEffect::GenBaseGradientKey(const GrDrawEffect& drawEffect) {
     const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>();
-    const GrTexture* texture = NULL;
 
-    if (GrGradientEffect::kTexture_ColorType == e.getColorType()){
-        texture = e.texture(0);
-    }
-
-    EffectKey key = GrGLEffectMatrix::GenKey(e.getMatrix(), drawEffect, kCoordsType, texture);
+    EffectKey key = 0;
 
     if (GrGradientEffect::kTwo_ColorType == e.getColorType()) {
         key |= kTwoColorKey;
     } else if (GrGradientEffect::kThree_ColorType == e.getColorType()){
         key |= kThreeColorKey;
     }
 
     if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
         key |= kPremulBeforeInterpKey;
     }
 
     return key;
 }
 
-void GrGLGradientEffect::setupMatrix(GrGLShaderBuilder* builder,
-                                     EffectKey key,
-                                     SkString* fsCoordName,
-                                     SkString* vsVaryingName,
-                                     GrSLType* vsVaryingType) {
-    fEffectMatrix.emitCodeMakeFSCoords2D(builder,
-                                         key & kMatrixKeyMask,
-                                         fsCoordName,
-                                         vsVaryingName,
-                                         vsVaryingType);
-}
-
 void GrGLGradientEffect::emitColor(GrGLShaderBuilder* builder,
                                    const char* gradientTValue,
                                    EffectKey key,
                                    const char* outputColor,
                                    const char* inputColor,
                                    const GrGLShaderBuilder::TextureSamplerArray& samplers) {
     if (GrGradientEffect::kTwo_ColorType == ColorTypeFromKey(key)){
         builder->fsCodeAppendf("\tvec4 colorTemp = mix(%s, %s, clamp(%s, 0.0, 1.0));\n",
                                builder->getUniformVariable(fColorStartUni).c_str(),
                                builder->getUniformVariable(fColorEndUni).c_str(),
@@ skipping 51 matching lines @@
     }
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GrGradientEffect::GrGradientEffect(GrContext* ctx,
                                    const SkGradientShaderBase& shader,
                                    const SkMatrix& matrix,
                                    SkShader::TileMode tileMode) {
 
-
-    fMatrix = matrix;
     fIsOpaque = shader.isOpaque();
 
     SkShader::GradientInfo info;
     SkScalar pos[3] = {0};
 
     info.fColorCount = 3;
     info.fColors = &fColors[0];
     info.fColorOffsets = &pos[0];
     shader.asAGradient(&info);
 
@@ skipping 10 matching lines @@
             fColorType = kThree_ColorType;
             foundSpecialCase = true;
         }
     }
     if (foundSpecialCase) {
         if (SkGradientShader::kInterpolateColorsInPremul_Flag & info.fGradientFlags) {
             fPremulType = kBeforeInterp_PremulType;
         } else {
             fPremulType = kAfterInterp_PremulType;
         }
+        fCoordTransform.reset(kCoordSet, matrix);
     } else {
         // doesn't matter how this is set, just be consistent because it is part of the effect key.
         fPremulType = kBeforeInterp_PremulType;
         SkBitmap bitmap;
         shader.getGradientTableBitmap(&bitmap);
         fColorType = kTexture_ColorType;
 
         GrTextureStripAtlas::Desc desc;
         desc.fWidth  = bitmap.width();
         desc.fHeight = 32;
         desc.fRowHeight = bitmap.height();
         desc.fContext = ctx;
         desc.fConfig = SkBitmapConfig2GrPixelConfig(bitmap.config());
         fAtlas = GrTextureStripAtlas::GetAtlas(desc);
         SkASSERT(NULL != fAtlas);
 
         // We always filter the gradient table. Each table is one row of a texture, always y-clamp.
         GrTextureParams params;
         params.setFilterMode(GrTextureParams::kBilerp_FilterMode);
         params.setTileModeX(tileMode);
 
         fRow = fAtlas->lockRow(bitmap);
         if (-1 != fRow) {
             fYCoord = fAtlas->getYOffset(fRow) + SK_ScalarHalf *
             fAtlas->getVerticalScaleFactor();
+            fCoordTransform.reset(kCoordSet, matrix, fAtlas->getTexture());
             fTextureAccess.reset(fAtlas->getTexture(), params);
         } else {
             GrTexture* texture = GrLockAndRefCachedBitmapTexture(ctx, bitmap, &params);
+            fCoordTransform.reset(kCoordSet, matrix, texture);
             fTextureAccess.reset(texture, params);
             fYCoord = SK_ScalarHalf;
 
             // Unlock immediately, this is not great, but we don't have a way of
             // knowing when else to unlock it currently, so it may get purged from
             // the cache, but it'll still be ref'd until it's no longer being used.
             GrUnlockAndUnrefCachedBitmapTexture(texture);
         }
         this->addTextureAccess(&fTextureAccess);
     }
+    this->addCoordTransform(&fCoordTransform);
 }
 
 GrGradientEffect::~GrGradientEffect() {
     if (this->useAtlas()) {
         fAtlas->unlockRow(fRow);
     }
 }
 
 bool GrGradientEffect::onIsEqual(const GrEffect& effect) const {
     const GrGradientEffect& s = CastEffect<GrGradientEffect>(effect);
@@ skipping 11 matching lines @@
                 *this->getColors(2) != *s.getColors(2)) {
                 return false;
             }
         }
 
         return fTextureAccess.getTexture() == s.fTextureAccess.getTexture()  &&
             fTextureAccess.getParams().getTileModeX() ==
                 s.fTextureAccess.getParams().getTileModeX() &&
             this->useAtlas() == s.useAtlas() &&
             fYCoord == s.getYCoord() &&
-            fMatrix.cheapEqualTo(s.getMatrix());
+            fCoordTransform.getMatrix().cheapEqualTo(s.fCoordTransform.getMatrix());
     }
 
     return false;
 }
 
 void GrGradientEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     if (fIsOpaque && (kA_GrColorComponentFlag & *validFlags) && 0xff == GrColorUnpackA(*color)) {
         *validFlags = kA_GrColorComponentFlag;
     } else {
         *validFlags = 0;
@@ skipping 18 matching lines @@
             (*stops)[i] = stop;
             stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
     *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
 
     return outColors;
 }
 
 #endif