mozilla
/
moz-skia
зеркало из https://github.com/mozilla/moz-skia.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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
This commit is contained in:
bsalomon@google.com 2011-12-12 16:10:08 +00:00
Родитель 4ad7e580e0
Коммит 1fadb20c50
8 изменённых файлов: 91 добавлений и 61 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

55
include/gpu/GrContext.h
Просмотреть файл

@ -107,15 +107,53 @@ 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;

4
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

6
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;

2
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);

59
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;
}

3
src/gpu/GrGpu.cpp
Просмотреть файл

@ -974,6 +974,3 @@ void GrGpu::printStats() const {
}
}
////////////////////////////////////////////////////////////////////////////////
const GrSamplerState GrSamplerState::gClampNearest;

21
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);
}

2
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;