Refactor helper function for SkBitmapShader to GrFragmentProcessor

src/core/SkBitmapProcShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ skipping 331 matching lines @@
 
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTextureAccess.h"
+#include "SkGr.h"
 #include "effects/GrSimpleTextureEffect.h"
-#include "SkGr.h"
 
 bool SkBitmapProcShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
                                              const SkMatrix& viewM,
                                              const SkMatrix* localMatrix, GrColor* paintColor,
                                              GrProcessorDataManager* procDataManager,
                                              GrFragmentProcessor** fp) const {
     SkMatrix matrix;
     matrix.setIDiv(fRawBitmap.width(), fRawBitmap.height());
 
     SkMatrix lmInverse;
@@ skipping 11 matching lines @@
 
     SkShader::TileMode tm[] = {
         (TileMode)fTileModeX,
         (TileMode)fTileModeY,
     };
 
     // Must set wrap and filter on the sampler before requesting a texture. In two places below
     // we check the matrix scale factors to determine how to interpret the filter quality setting.
     // This completely ignores the complexity of the drawVertices case where explicit local coords
     // are provided by the caller.
-    bool useBicubic = false;
-    GrTextureParams::FilterMode textureFilterMode;
-    switch(paint.getFilterQuality()) {
-        case kNone_SkFilterQuality:
-            textureFilterMode = GrTextureParams::kNone_FilterMode;
-            break;
-        case kLow_SkFilterQuality:
-            textureFilterMode = GrTextureParams::kBilerp_FilterMode;
-            break;
-        case kMedium_SkFilterQuality: {
-            SkMatrix matrix;
-            matrix.setConcat(viewM, this->getLocalMatrix());
-            if (matrix.getMinScale() < SK_Scalar1) {
-                textureFilterMode = GrTextureParams::kMipMap_FilterMode;
-            } else {
-                // Don't trigger MIP level generation unnecessarily.
-                textureFilterMode = GrTextureParams::kBilerp_FilterMode;
-            }
-            break;
-        }
-        case kHigh_SkFilterQuality: {
-            SkMatrix matrix;
-            matrix.setConcat(viewM, this->getLocalMatrix());
-            useBicubic = GrBicubicEffect::ShouldUseBicubic(matrix, &textureFilterMode);
-            break;
-        }
-        default:
-            SkErrorInternals::SetError( kInvalidPaint_SkError,
-                                        "Sorry, I don't understand the filtering "
-                                        "mode you asked for.  Falling back to "
-                                        "MIPMaps.");
-            textureFilterMode = GrTextureParams::kMipMap_FilterMode;
-            break;
-
-    }
+    bool doBicubic;
+    GrTextureParams::FilterMode textureFilterMode =
+            GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), viewM, this->getLocalMatrix(),
+                                            &doBicubic);
     GrTextureParams params(tm, textureFilterMode);
     SkAutoTUnref<GrTexture> texture(GrRefCachedBitmapTexture(context, fRawBitmap, &params));
 
     if (!texture) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "Couldn't convert bitmap to texture.");
         return false;
     }
 
     *paintColor = (kAlpha_8_SkColorType == fRawBitmap.colorType()) ?
                                                 SkColor2GrColor(paint.getColor()) :
                                                 SkColor2GrColorJustAlpha(paint.getColor());
 
-    if (useBicubic) {
+    if (doBicubic) {
         *fp = GrBicubicEffect::Create(procDataManager, texture, matrix, tm);
     } else {
         *fp = GrSimpleTextureEffect::Create(procDataManager, texture, matrix, params);
     }
 
     return true;
 }
 
 #else
 
 bool SkBitmapProcShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                              const SkMatrix*, GrColor*, GrProcessorDataManager*,
                                              GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif