#include "SkTwoPointRadialGradient.h"
#include "SkTwoPointConicalGradient.h"
#include "SkSweepGradient.h"
+#include "effects/GrTextureStripAtlas.h"
SkGradientShaderBase::SkGradientShaderBase(const SkColor colors[], const SkScalar pos[],
int colorCount, SkShader::TileMode mode, SkUnitMapper* mapper) {
#include "SkGr.h"
GrGLGradientStage::GrGLGradientStage(const GrProgramStageFactory& factory)
- : INHERITED(factory) { }
+ : INHERITED(factory)
+ , fCachedYCoord(GR_ScalarMax)
+ , fFSYUni(GrGLUniformManager::kInvalidUniformHandle) { }
GrGLGradientStage::~GrGLGradientStage() { }
+void GrGLGradientStage::setupVariables(GrGLShaderBuilder* builder) {
+ fFSYUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+ kFloat_GrSLType, "GradientYCoordFS");
+}
+
+void GrGLGradientStage::setData(const GrGLUniformManager& uman,
+ const GrCustomStage& stage,
+ const GrRenderTarget*,
+ int stageNum) {
+ GrScalar yCoord = static_cast<const GrGradientEffect&>(stage).getYCoord();
+ if (yCoord != fCachedYCoord) {
+ uman.set1f(fFSYUni, yCoord);
+ fCachedYCoord = yCoord;
+ }
+}
+
void GrGLGradientStage::emitColorLookup(GrGLShaderBuilder* builder,
const char* tName,
const char* outputColor,
const char* samplerName) {
- // Texture is effectively 1D so the y coordinate is 0.5, if we pack multiple
- // gradients into a texture, we could instead pick the appropriate row here
- builder->fSampleCoords.printf("vec2(%s, 0.5)", tName);
+ builder->fSampleCoords.printf("vec2(%s, %s)", tName,
+ builder->getUniformVariable(fFSYUni).c_str());
builder->fComplexCoord = true;
builder->emitDefaultFetch(outputColor, samplerName);
}
const SkGradientShaderBase& shader,
GrSamplerState* sampler)
: fTexture (NULL)
- , fUseTexture (false) {
+ , fUseTexture (true) {
// TODO: check for simple cases where we don't need a texture:
//GradientInfo info;
//shader.asAGradient(&info);
SkBitmap bitmap;
shader.getGradientTableBitmap(&bitmap);
- GrContext::TextureCacheEntry entry = GrLockCachedBitmapTexture(ctx, bitmap,
- sampler->textureParams());
- fTexture = entry.texture();
- SkSafeRef(fTexture);
- fUseTexture = true;
+ GrTextureStripAtlas::Desc desc;
+ desc.fWidth = bitmap.width();
+ desc.fHeight = 32;
+ desc.fRowHeight = bitmap.height();
+ desc.fContext = ctx;
+ desc.fConfig = SkBitmapConfig2GrPixelConfig(bitmap.config());
+ fAtlas = GrTextureStripAtlas::GetAtlas(desc);
+ GrAssert(NULL != fAtlas);
+
+ fRow = fAtlas->lockRow(bitmap);
+ if (-1 != fRow) {
+ fYCoord = fAtlas->getYOffset(fRow) + GR_ScalarHalf *
+ fAtlas->getVerticalScaleFactor();
+ fTexture = fAtlas->getTexture();
+ } else {
+ GrContext::TextureCacheEntry entry = GrLockCachedBitmapTexture(ctx, bitmap,
+ sampler->textureParams());
+ fTexture = entry.texture();
+ SkSafeRef(fTexture);
+ fYCoord = GR_ScalarHalf;
- // Unlock immediately, this is not great, but we don't have a way of
- // knowing when else to unlock it currently, so it may get purged from
- // the cache, but it'll still be ref'd until it's no longer being used.
- GrUnlockCachedBitmapTexture(ctx, entry);
+ // Unlock immediately, this is not great, but we don't have a way of
+ // knowing when else to unlock it currently, so it may get purged from
+ // the cache, but it'll still be ref'd until it's no longer being used.
+ GrUnlockCachedBitmapTexture(ctx, entry);
+ }
}
GrGradientEffect::~GrGradientEffect() {
- SkSafeUnref(fTexture);
+ if (this->useAtlas()) {
+ fAtlas->unlockRow(fRow);
+ } else {
+ SkSafeUnref(fTexture);
+ }
}
unsigned int GrGradientEffect::numTextures() const {
* determines the gradient value.
*/
+ class GrTextureStripAtlas;
+
// Base class for Gr gradient effects
class GrGradientEffect : public GrCustomStage {
public:
GrTexture* texture(unsigned int index) const;
bool useTexture() const { return fUseTexture; }
+ bool useAtlas() const { return SkToBool(-1 != fRow); }
+ GrScalar getYCoord() const { GrAssert(fUseTexture); return fYCoord; };
+
+ bool isEqual(const GrCustomStage& stage) const {
+ const GrGradientEffect& s = static_cast<const GrGradientEffect&>(stage);
+ return INHERITED::isEqual(stage) && this->useAtlas() == s.useAtlas() &&
+ fYCoord == s.getYCoord();
+ }
protected:
private:
GrTexture* fTexture;
bool fUseTexture;
+ GrScalar fYCoord;
+ GrTextureStripAtlas* fAtlas;
+ int fRow;
typedef GrCustomStage INHERITED;
GrGLGradientStage(const GrProgramStageFactory& factory);
virtual ~GrGLGradientStage();
+ virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
+ virtual void setData(const GrGLUniformManager&,
+ const GrCustomStage&,
+ const GrRenderTarget*,
+ int stageNum) SK_OVERRIDE;
+
// emit code that gets a fragment's color from an expression for t; for now
// this always uses the texture, but for simpler cases we'll be able to lerp
void emitColorLookup(GrGLShaderBuilder* builder, const char* t,
private:
+ GrScalar fCachedYCoord;
+ GrGLUniformManager::UniformHandle fFSYUni;
+
typedef GrGLProgramStage INHERITED;
};
}
void GrGLConical2Gradient::setupVariables(GrGLShaderBuilder* builder) {
+ INHERITED::setupVariables(builder);
// 2 copies of uniform array, 1 for each of vertex & fragment shader,
// to work around Xoom bug. Doesn't seem to cause performance decrease
// in test apps, but need to keep an eye on it.
void GrGLConical2Gradient::setData(const GrGLUniformManager& uman,
const GrCustomStage& baseData,
- const GrRenderTarget*,
+ const GrRenderTarget* target,
int stageNum) {
+ INHERITED::setData(uman, baseData, target, stageNum);
const GrConical2Gradient& data =
static_cast<const GrConical2Gradient&>(baseData);
GrAssert(data.isDegenerate() == fIsDegenerate);
}
void GrGLRadial2Gradient::setupVariables(GrGLShaderBuilder* builder) {
+ INHERITED::setupVariables(builder);
// 2 copies of uniform array, 1 for each of vertex & fragment shader,
// to work around Xoom bug. Doesn't seem to cause performance decrease
// in test apps, but need to keep an eye on it.
void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,
const GrCustomStage& baseData,
- const GrRenderTarget*,
+ const GrRenderTarget* target,
int stageNum) {
+ INHERITED::setData(uman, baseData, target, stageNum);
const GrRadial2Gradient& data =
static_cast<const GrRadial2Gradient&>(baseData);
GrAssert(data.isDegenerate() == fIsDegenerate);
GrTextureStripAtlas* fAtlas;
};
-// Ugly way of ensuring that we clean up the atlases on exit
-struct AtlasEntries {
- ~AtlasEntries() { fEntries.deleteAll(); }
- SkTDArray<AtlasEntry*> fEntries;
-};
-
GrTextureStripAtlas* GrTextureStripAtlas::GetAtlas(const GrTextureStripAtlas::Desc& desc) {
- static AtlasEntries gAtlasEntries;
+ static SkTDArray<AtlasEntry> gAtlasEntries;
static GrTHashTable<AtlasEntry, AtlasHashKey, 8> gAtlasCache;
AtlasHashKey key;
key.setKeyData(desc.asKey());
if (NULL != entry) {
return entry->fAtlas;
} else {
- entry = SkNEW(AtlasEntry);
- gAtlasEntries.fEntries.push(entry);
+ entry = gAtlasEntries.push();
entry->fAtlas = SkNEW_ARGS(GrTextureStripAtlas, (desc));
entry->fKey = key;
gAtlasCache.insert(key, entry);
this->removeFromLRU(row);
uint32_t oldKey = row->fKey;
- row->fKey = key;
- row->fLocks = 1;
// If we are writing into a row that already held bitmap data, we need to remove the
// reference to that genID which is stored in our sorted table of key values.
// Find the entry in the list; if it's before the index where we plan on adding the new
// entry, we decrement since it will shift elements ahead of it back by one.
int oldIndex = this->searchByKey(oldKey);
- if (oldIndex <= index) {
+ if (oldIndex < index) {
--index;
}
fKeyTable.remove(oldIndex);
}
+ row->fKey = key;
+ row->fLocks = 1;
fKeyTable.insert(index, 1, &row);
rowNumber = static_cast<int>(row - fRows);
projects / platform / upstream / libSkiaSharp.git / commitdiff