make the filter mode for GrTextureAccess an enum so we can plumb down

src/gpu/GrTexture.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 "GrTexture.h"
@@ skipping 95 matching lines @@
 
 // These flags need to fit in a GrResourceKey::ResourceFlags so they can be folded into the texture
 // key
 enum TextureFlags {
     /**
      * The kStretchToPOT bit is set when the texture is NPOT and is being repeated but the
      * hardware doesn't support that feature.
      */
     kStretchToPOT_TextureFlag = 0x1,
     /**
-     * The kFilter bit can only be set when the kStretchToPOT flag is set and indicates whether the
-     * stretched texture should be bilerp filtered or point sampled.
+     * The kBilerp bit can only be set when the kStretchToPOT flag is set and indicates whether the
+     * stretched texture should be bilerped.
      */
-    kFilter_TextureFlag       = 0x2,
+     kBilerp_TextureFlag       = 0x2,
+    /**
+     * The kMipMap bit can only be set when the kStretchToPOT flag is set and indicates whether the
+     * stretched texture should have mipmaps computed.
+     */
+     kMipMap_TextureFlag       = 0x4,
 };
 
 namespace {
 GrResourceKey::ResourceFlags get_texture_flags(const GrGpu* gpu,
                                                const GrTextureParams* params,
                                                const GrTextureDesc& desc) {
     GrResourceKey::ResourceFlags flags = 0;
     bool tiled = NULL != params && params->isTiled();
     if (tiled && !gpu->caps()->npotTextureTileSupport()) {
         if (!GrIsPow2(desc.fWidth) || !GrIsPow2(desc.fHeight)) {
             flags |= kStretchToPOT_TextureFlag;
-            if (params->isBilerp()) {
-                flags |= kFilter_TextureFlag;
+            switch(params->filterMode()) {
+                case GrTextureParams::kNone_FilterMode:
+                    break;
+                case GrTextureParams::kBilerp_FilterMode:
+                    flags |= kBilerp_TextureFlag;
+                    break;
+                case GrTextureParams::kMipMap_FilterMode:
+                    flags |= kMipMap_TextureFlag;
+                    break;
             }
         }
     }
     return flags;
 }
 
 GrResourceKey::ResourceType texture_resource_type() {
     static const GrResourceKey::ResourceType gType = GrResourceKey::GenerateResourceType();
     return gType;
 }
@@ skipping 36 matching lines @@
     memset(idKey.fData8 + 16, 0, kPadSize);
 
     GrCacheID cacheID(GrResourceKey::ScratchDomain(), idKey);
     return GrResourceKey(cacheID, texture_resource_type(), 0);
 }
 
 bool GrTexture::NeedsResizing(const GrResourceKey& key) {
     return SkToBool(key.getResourceFlags() & kStretchToPOT_TextureFlag);
 }
 
-bool GrTexture::NeedsFiltering(const GrResourceKey& key) {
-    return SkToBool(key.getResourceFlags() & kFilter_TextureFlag);
+bool GrTexture::NeedsBilerp(const GrResourceKey& key) {
+    return SkToBool(key.getResourceFlags() & kBilerp_TextureFlag);
 }
+
+bool GrTexture::NeedsMipMap(const GrResourceKey& key) {
+    return SkToBool(key.getResourceFlags() & kMipMap_TextureFlag);
+}