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

src/gpu/GrContext.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 "GrContext.h"
@@ skipping 288 matching lines @@
 };
 
 };
 
 // The desired texture is NPOT and tiled but that isn't supported by
 // the current hardware. Resize the texture to be a POT
 GrTexture* GrContext::createResizedTexture(const GrTextureDesc& desc,
                                            const GrCacheID& cacheID,
                                            void* srcData,
                                            size_t rowBytes,
-                                           bool needsFiltering) {
+                                           GrTextureParams::FilterMode filterMode) {
     SkAutoTUnref<GrTexture> clampedTexture(this->findAndRefTexture(desc, cacheID, NULL));
     if (NULL == clampedTexture) {
         clampedTexture.reset(this->createTexture(NULL, desc, cacheID, srcData, rowBytes));
 
         if (NULL == clampedTexture) {
             return NULL;
         }
     }
 
     GrTextureDesc rtDesc = desc;
     rtDesc.fFlags =  rtDesc.fFlags |
                      kRenderTarget_GrTextureFlagBit |
                      kNoStencil_GrTextureFlagBit;
     rtDesc.fWidth  = GrNextPow2(GrMax(desc.fWidth, 64));
     rtDesc.fHeight = GrNextPow2(GrMax(desc.fHeight, 64));
 
     GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
 
     if (NULL != texture) {
         GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
         GrDrawState* drawState = fGpu->drawState();
         drawState->setRenderTarget(texture->asRenderTarget());
 
         // if filtering is not desired then we want to ensure all
         // texels in the resampled image are copies of texels from
         // the original.
-        GrTextureParams params(SkShader::kClamp_TileMode, needsFiltering);
+        GrTextureParams params(SkShader::kClamp_TileMode, filterMode);

[bsalomon, 2013/07/25 17:41:48]

Actually I think we just want to set knone or kbilerp here..

Unextended ES2 doesn't allow NPOT textures to be used with mip filtering or wrap
modes other than clamp.

This function will stretch the base level of a NPOT texture to the next POT so
that it can be used with wrap modes or mipmaps.

We do a non-bilerp stretch when the caller asked for an unfiltered draw. This
means that the stretched texture only has pixel values that were present in the
original bitmap. Whether the stretch was bilerped or not is recorded in the key
for the stretched texture so that we one when the caller asks for no filtering
and the other with filtering. I think the filtered stretched version could be
used for both the mip and bilerp cases.

Maybe we should go back to having a bool for NeedsFiltering() and just rename it
to NeedsFilteringOrMips().

This whole thing is of decreasing relevance as all the newer GPUs support the
extension that removes the limitations on NPOT.

         drawState->addColorTextureEffect(clampedTexture, SkMatrix::I(), params);
 
         drawState->setVertexAttribs<gVertexAttribs>(SK_ARRAY_COUNT(gVertexAttribs));
 
         GrDrawTarget::AutoReleaseGeometry arg(fGpu, 4, 0);
 
         if (arg.succeeded()) {
             GrPoint* verts = (GrPoint*) arg.vertices();
             verts[0].setIRectFan(0, 0, texture->width(), texture->height(), 2 * sizeof(GrPoint));
             verts[1].setIRectFan(0, 0, 1, 1, 2 * sizeof(GrPoint));
@@ skipping 28 matching lines @@
                                     const GrTextureDesc& desc,
                                     const GrCacheID& cacheID,
                                     void* srcData,
                                     size_t rowBytes) {
     SK_TRACE_EVENT0("GrContext::createTexture");
 
     GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheID);
 
     GrTexture* texture;
     if (GrTexture::NeedsResizing(resourceKey)) {
+        GrTextureParams::FilterMode textureFilterMode = GrTextureParams::kNone_FilterMode;
+        if (GrTexture::NeedsBilerp(resourceKey)) {
+            textureFilterMode = GrTextureParams::kBilerp_FilterMode;
+        } else if (GrTexture::NeedsMipMap(resourceKey)) {
+            textureFilterMode = GrTextureParams::kMipMap_FilterMode;
+        }
         texture = this->createResizedTexture(desc, cacheID,
                                              srcData, rowBytes,
-                                             GrTexture::NeedsFiltering(resourceKey));
+                                             textureFilterMode);
     } else {
         texture= fGpu->createTexture(desc, srcData, rowBytes);
     }
 
     if (NULL != texture) {
         // Adding a resource could put us overbudget. Try to free up the
         // necessary space before adding it.
         fTextureCache->purgeAsNeeded(1, texture->sizeInBytes());
         fTextureCache->addResource(resourceKey, texture);
     }
@@ skipping 1306 matching lines @@
         return NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif