Remove static initiazled gClampNearest in gpu backend

Review URL: http://codereview.appspot.com/5487044/

git-svn-id: http://skia.googlecode.com/svn/trunk@2851 2bbb7eff-a529-9590-31e7-b0007b416f81

diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 5b48c0b..8a838ea 100644 (file)
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -108,14 +108,52 @@ public:
     typedef uint64_t TextureKey;
 
     /**
+     *  Create a new entry, based on the specified key and texture, and return
+     *  its "locked" entry. Must call be balanced with an unlockTexture() call.
+     *
+     *  @param key      A client-generated key that identifies the contents
+     *                  of the texture. Respecified to findAndLockTexture
+     *                  for subsequent uses of the texture.
+     *  @param sampler  The sampler state used to draw a texture may be used
+     *                  to determine how to store the pixel data in the texture
+     *                  cache. (e.g. different versions may exist for different
+     *                  wrap modes on GPUs with limited or no NPOT texture
+     *                  support). Only the wrap and filter fields are used. NULL
+     *                  implies clamp wrap modes and nearest filtering.
+     * @param desc      Description of the texture properties.
+     * @param srcData   Pointer to the pixel values.
+     * @param rowBytes  The number of bytes between rows of the texture. Zero
+     *                  implies tightly packed rows.
+     */
+    TextureCacheEntry createAndLockTexture(TextureKey key,
+                                           const GrSamplerState* sampler,
+                                           const GrTextureDesc& desc,
+                                           void* srcData, size_t rowBytes);
+
+    /**
      *  Search for an entry based on key and dimensions. If found, "lock" it and
      *  return it. The entry's texture() function will return NULL if not found.
-     *  Must call be balanced with an unlockTexture() call.
+     *  Must be balanced with an unlockTexture() call.
+     *
+     *  @param key      A client-generated key that identifies the contents
+     *                  of the texture.
+     *  @param width    The width of the texture in pixels as specifed in
+     *                  the GrTextureDesc originally passed to
+     *                  createAndLockTexture
+     *  @param width    The height of the texture in pixels as specifed in
+     *                  the GrTextureDesc originally passed to
+     *                  createAndLockTexture
+     *  @param sampler  The sampler state used to draw a texture may be used
+     *                  to determine the cache entry used. (e.g. different
+     *                  versions may exist for different wrap modes on GPUs with
+     *                  limited or no NPOT texture support). Only the wrap and 
+     *                  filter fields are used. NULL implies clamp wrap modes
+     *                  and nearest filtering.
      */
     TextureCacheEntry findAndLockTexture(TextureKey key,
                                          int width,
                                          int height,
-                                         const GrSamplerState&);
+                                         const GrSamplerState* sampler);
     /**
      * Determines whether a texture is in the cache. If the texture is found it
      * will not be locked or returned. This call does not affect the priority of
@@ -124,16 +162,7 @@ public:
     bool isTextureInCache(TextureKey key,
                           int width,
                           int height,
-                          const GrSamplerState&) const;
-
-    /**
-     *  Create a new entry, based on the specified key and texture, and return
-     *  its "locked" entry. Must call be balanced with an unlockTexture() call.
-     */
-    TextureCacheEntry createAndLockTexture(TextureKey key,
-                                           const GrSamplerState&,
-                                           const GrTextureDesc&,
-                                           void* srcData, size_t rowBytes);
+                          const GrSamplerState*) const;
 
     /**
      * Enum that determines how closely a returned scratch texture must match
@@ -186,7 +215,7 @@ public:
     /**
      *  Returns true if the specified use of an indexed texture is supported.
      */
-    bool supportsIndex8PixelConfig(const GrSamplerState&,
+    bool supportsIndex8PixelConfig(const GrSamplerState*,
                                    int width,
                                    int height) const;
 

diff --git a/include/gpu/GrSamplerState.h b/include/gpu/GrSamplerState.h
index 42e9d0d..c0f7fd4 100644 (file)
--- a/include/gpu/GrSamplerState.h
+++ b/include/gpu/GrSamplerState.h
@@ -224,8 +224,6 @@ public:
         }
     }
 
-    static const GrSamplerState& ClampNearest() { return gClampNearest; }
-
 private:
     WrapMode    fWrapX : 8;
     WrapMode    fWrapY : 8;
@@ -244,8 +242,6 @@ private:
     uint8_t     fKernelWidth;
     float       fImageIncrement[2];
     float       fKernel[MAX_KERNEL_WIDTH];
-
-    static const GrSamplerState gClampNearest;
 };
 
 #endif

diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
index eacf020..6bafa94 100644 (file)
--- a/include/gpu/SkGpuDevice.h
+++ b/include/gpu/SkGpuDevice.h
@@ -118,7 +118,7 @@ protected:
         kSaveLayerDeviceRenderTarget_TexType
     };
     TexCache lockCachedTexture(const SkBitmap& bitmap,
-                               const GrSamplerState& sampler,
+                               const GrSamplerState* sampler,
                                TexType type = kBitmap_TexType);
     bool isBitmapInTextureCache(const SkBitmap& bitmap,
                                 const GrSamplerState& sampler) const;
@@ -129,11 +129,11 @@ protected:
         SkAutoCachedTexture();
         SkAutoCachedTexture(SkGpuDevice* device,
                             const SkBitmap& bitmap,
-                            const GrSamplerState& sampler,
+                            const GrSamplerState* sampler,
                             GrTexture** texture);
         ~SkAutoCachedTexture();
 
-        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
+        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState*);
 
     private:
         SkGpuDevice*    fDevice;

diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index ad157d5..f4dab53 100644 (file)
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -199,7 +199,7 @@ private:
 static const GrContext::TextureKey gUNCACHED_KEY = ~0;
 GrContext::TextureCacheEntry sk_gr_create_bitmap_texture(GrContext* ctx,
                                                 GrContext::TextureKey key,
-                                                const GrSamplerState& sampler,
+                                                const GrSamplerState* sampler,
                                                 const SkBitmap& bitmap);
 
 

diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index de36307..a798ec9 100644 (file)
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -7,9 +7,10 @@
  */
 
 
+#include "GrContext.h"
+
 #include "GrBufferAllocPool.h"
 #include "GrClipIterator.h"
-#include "GrContext.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrInOrderDrawBuffer.h"
@@ -158,7 +159,7 @@ GrTexture* GrContext::TextureCacheEntry::texture() const {
 namespace {
 // returns true if this is a "special" texture because of gpu NPOT limitations
 bool gen_texture_key_values(const GrGpu* gpu,
-                            const GrSamplerState& sampler,
+                            const GrSamplerState* sampler,
                             GrContext::TextureKey clientKey,
                             int width,
                             int height,
@@ -177,12 +178,13 @@ bool gen_texture_key_values(const GrGpu* gpu,
     if (!gpu->getCaps().fNPOTTextureTileSupport) {
         bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
 
-        bool tiled = (sampler.getWrapX() != GrSamplerState::kClamp_WrapMode) ||
-                     (sampler.getWrapY() != GrSamplerState::kClamp_WrapMode);
+        bool tiled = NULL != sampler &&
+                     ((sampler->getWrapX() != GrSamplerState::kClamp_WrapMode) ||
+                      (sampler->getWrapY() != GrSamplerState::kClamp_WrapMode));
 
         if (tiled && !isPow2) {
             v[3] |= kNPOTBit;
-            if (GrSamplerState::kNearest_Filter != sampler.getFilter()) {
+            if (GrSamplerState::kNearest_Filter != sampler->getFilter()) {
                 v[3] |= kFilterBit;
             }
         }
@@ -232,10 +234,11 @@ void reset_draw_state(GrDrawState* drawState){
 }
 }
 
-GrContext::TextureCacheEntry GrContext::findAndLockTexture(TextureKey key,
-                                                           int width,
-                                                           int height,
-                                                const GrSamplerState& sampler) {
+GrContext::TextureCacheEntry GrContext::findAndLockTexture(
+        TextureKey key,
+        int width,
+        int height,
+        const GrSamplerState* sampler) {
     uint32_t v[4];
     gen_texture_key_values(fGpu, sampler, key, width, height, false, v);
     GrResourceKey resourceKey(v);
@@ -246,7 +249,7 @@ GrContext::TextureCacheEntry GrContext::findAndLockTexture(TextureKey key,
 bool GrContext::isTextureInCache(TextureKey key,
                                  int width,
                                  int height,
-                                 const GrSamplerState& sampler) const {
+                                 const GrSamplerState* sampler) const {
     uint32_t v[4];
     gen_texture_key_values(fGpu, sampler, key, width, height, false, v);
     GrResourceKey resourceKey(v);
@@ -308,10 +311,12 @@ static void stretchImage(void* dst,
     }
 }
 
-GrContext::TextureCacheEntry GrContext::createAndLockTexture(TextureKey key,
-                                                const GrSamplerState& sampler,
-                                                const GrTextureDesc& desc,
-                                                void* srcData, size_t rowBytes) {
+GrContext::TextureCacheEntry GrContext::createAndLockTexture(
+        TextureKey key,
+        const GrSamplerState* sampler,
+        const GrTextureDesc& desc,
+        void* srcData,
+        size_t rowBytes) {
     SK_TRACE_EVENT0("GrContext::createAndLockTexture");
 
 #if GR_DUMP_TEXTURE_UPLOAD
@@ -325,14 +330,15 @@ GrContext::TextureCacheEntry GrContext::createAndLockTexture(TextureKey key,
     GrResourceKey resourceKey(v);
 
     if (special) {
-        TextureCacheEntry clampEntry = 
-                            findAndLockTexture(key, desc.fWidth, desc.fHeight,
-                                               GrSamplerState::ClampNearest());
+        GrAssert(NULL != sampler);
+        TextureCacheEntry clampEntry = this->findAndLockTexture(key,
+                                                                desc.fWidth,
+                                                                desc.fHeight,
+                                                                NULL);
 
         if (NULL == clampEntry.texture()) {
-            clampEntry = createAndLockTexture(key,
-                                              GrSamplerState::ClampNearest(),
-                                              desc, srcData, rowBytes);
+            clampEntry = this->createAndLockTexture(key, NULL, desc,
+                                                    srcData, rowBytes);
             GrAssert(NULL != clampEntry.texture());
             if (NULL == clampEntry.texture()) {
                 return entry;
@@ -358,7 +364,7 @@ GrContext::TextureCacheEntry GrContext::createAndLockTexture(TextureKey key,
             // if filtering is not desired then we want to ensure all
             // texels in the resampled image are copies of texels from
             // the original.
-            if (GrSamplerState::kNearest_Filter == sampler.getFilter()) {
+            if (GrSamplerState::kNearest_Filter == sampler->getFilter()) {
                 filter = GrSamplerState::kNearest_Filter;
             } else {
                 filter = GrSamplerState::kBilinear_Filter;
@@ -430,8 +436,8 @@ inline void gen_scratch_tex_key_values(const GrGpu* gpu,
                                     ((uint64_t) desc.fConfig << 32);
     // this code path isn't friendly to tiling with NPOT restricitons
     // We just pass ClampNoFilter()
-    gen_texture_key_values(gpu, GrSamplerState::ClampNearest(), descKey,
-                            desc.fWidth, desc.fHeight, true, v);
+    gen_texture_key_values(gpu, NULL, descKey, desc.fWidth,
+                           desc.fHeight, true, v);
 }
 }
 
@@ -573,7 +579,7 @@ GrResource* GrContext::createPlatformSurface(const GrPlatformSurfaceDesc& desc)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool GrContext::supportsIndex8PixelConfig(const GrSamplerState& sampler,
+bool GrContext::supportsIndex8PixelConfig(const GrSamplerState* sampler,
                                           int width, int height) const {
     const GrDrawTarget::Caps& caps = fGpu->getCaps();
     if (!caps.f8BitPaletteSupport) {
@@ -583,8 +589,9 @@ bool GrContext::supportsIndex8PixelConfig(const GrSamplerState& sampler,
     bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
 
     if (!isPow2) {
-        bool tiled = sampler.getWrapX() != GrSamplerState::kClamp_WrapMode ||
-                     sampler.getWrapY() != GrSamplerState::kClamp_WrapMode;
+        bool tiled = NULL != sampler &&
+                     (sampler->getWrapX() != GrSamplerState::kClamp_WrapMode ||
+                      sampler->getWrapY() != GrSamplerState::kClamp_WrapMode);
         if (tiled && !caps.fNPOTTextureTileSupport) {
             return false;
         }

diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index a949acd..4a2e5d7 100644 (file)
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -974,6 +974,3 @@ void GrGpu::printStats() const {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-const GrSamplerState GrSamplerState::gClampNearest;

diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index df2ac22..bf00fa3 100644 (file)
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -59,7 +59,7 @@ enum {
 SkGpuDevice::SkAutoCachedTexture::
              SkAutoCachedTexture(SkGpuDevice* device,
                                  const SkBitmap& bitmap,
-                                 const GrSamplerState& sampler,
+                                 const GrSamplerState* sampler,
                                  GrTexture** texture) {
     GrAssert(texture);
     *texture = this->set(device, bitmap, sampler);
@@ -70,7 +70,7 @@ SkGpuDevice::SkAutoCachedTexture::SkAutoCachedTexture() {
 
 GrTexture* SkGpuDevice::SkAutoCachedTexture::set(SkGpuDevice* device,
                                                  const SkBitmap& bitmap,
-                                                 const GrSamplerState& sampler) {
+                                                 const GrSamplerState* sampler) {
     if (fTex.texture()) {
         fDevice->unlockCachedTexture(fTex);
     }
@@ -195,7 +195,7 @@ SkGpuDevice::SkGpuDevice(GrContext* context, SkBitmap::Config config, int width,
     TexType type = (kSaveLayer_Usage == usage) ? 
                             kSaveLayerDeviceRenderTarget_TexType :
                             kDeviceRenderTarget_TexType;
-    fCache = this->lockCachedTexture(bm, GrSamplerState::ClampNearest(), type);
+    fCache = this->lockCachedTexture(bm, NULL, type);
     fTexture = fCache.texture();
     if (fTexture) {
         SkASSERT(NULL != fTexture->asRenderTarget());
@@ -515,7 +515,7 @@ bool SkGpuDevice::skPaint2GrPaintShader(const SkPaint& skPaint,
                                   twoPointParams[2] < 0);
     }
 
-    GrTexture* texture = act->set(this, bitmap, *sampler);
+    GrTexture* texture = act->set(this, bitmap, sampler);
     if (NULL == texture) {
         SkDebugf("Couldn't convert bitmap to texture.\n");
         return false;
@@ -1407,7 +1407,7 @@ void SkGpuDevice::internalDrawBitmap(const SkDraw& draw,
     sampler->setMatrix(GrMatrix::I());
 
     GrTexture* texture;
-    SkAutoCachedTexture act(this, bitmap, *sampler, &texture);
+    SkAutoCachedTexture act(this, bitmap, sampler, &texture);
     if (NULL == texture) {
         return;
     }
@@ -1470,7 +1470,7 @@ void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
 
     GrTexture* texture;
     sampler->reset();
-    SkAutoCachedTexture act(this, bitmap, *sampler, &texture);
+    SkAutoCachedTexture act(this, bitmap, sampler, &texture);
 
     grPaint.setTexture(kBitmapTextureIdx, texture);
 
@@ -1755,7 +1755,7 @@ void SkGpuDevice::flush() {
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGpuDevice::TexCache SkGpuDevice::lockCachedTexture(const SkBitmap& bitmap,
-                                            const GrSamplerState& sampler,
+                                            const GrSamplerState* sampler,
                                             TexType type) {
     GrContext::TextureCacheEntry entry;
     GrContext* ctx = this->context();
@@ -1787,11 +1787,12 @@ SkGpuDevice::TexCache SkGpuDevice::lockCachedTexture(const SkBitmap& bitmap,
             entry = ctx->findAndLockTexture(key, bitmap.width(),
                                             bitmap.height(), sampler);
             if (NULL == entry.texture()) {
-                entry = sk_gr_create_bitmap_texture(ctx, key, sampler, 
+                entry = sk_gr_create_bitmap_texture(ctx, key, sampler,
                                                     bitmap);
             }
         } else {
-            entry = sk_gr_create_bitmap_texture(ctx, gUNCACHED_KEY, sampler, bitmap);
+            entry = sk_gr_create_bitmap_texture(ctx, gUNCACHED_KEY,
+                                                sampler, bitmap);
         }
         if (NULL == entry.texture()) {
             GrPrintf("---- failed to create texture for cache [%d %d]\n",
@@ -1810,7 +1811,7 @@ bool SkGpuDevice::isBitmapInTextureCache(const SkBitmap& bitmap,
     GrContext::TextureKey key = bitmap.getGenerationID();
     key |= ((uint64_t) bitmap.pixelRefOffset()) << 32;
     return this->context()->isTextureInCache(key, bitmap.width(),
-                                             bitmap.height(), sampler);
+                                             bitmap.height(), &sampler);
 
 }
 

diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 761a46b..0205dd6 100644 (file)
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -58,7 +58,7 @@ static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
 
 GrContext::TextureCacheEntry sk_gr_create_bitmap_texture(GrContext* ctx,
                                                 GrContext::TextureKey key,
-                                                const GrSamplerState& sampler,
+                                                const GrSamplerState* sampler,
                                                 const SkBitmap& origBitmap) {
     SkAutoLockPixels alp(origBitmap);
     GrContext::TextureCacheEntry entry;