AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Improved distance field sampling

Browse Source 
There are two different fixes here. First, it computes the distance value properly within the shader. Second, it handles anti-aliasing properly by doing a correction based on the gradient of the texture coordinates.

R=bsalomon@google.com, reed@google.com

Author: jvanverth@google.com

Review URL: https://codereview.chromium.org/149853002

git-svn-id: http://skia.googlecode.com/svn/trunk@13461 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
commit-bot@chromium.org 2014-02-14 21:48:29 +00:00
parent 9836bc3fdd
commit 6c89c34614
6 changed files with 79 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/gpu/GrAtlas.cpp
View File

@ -236,3 +236,7 @@ void GrAtlasMgr::freePlot(GrPlot* plot) {
// GrPrintf("~GrPlot %p [%d %d] %d\n", this, plot->fOffset.fX, plot->fOffset.fY, gCounter);
#endif
}
SkISize GrAtlas::getSize() const {
return SkISize::Make(GR_ATLAS_TEXTURE_WIDTH, GR_ATLAS_TEXTURE_HEIGHT);
}

2
src/gpu/GrAtlas.h
View File

@ -99,6 +99,8 @@ public:
bool isEmpty() { return NULL == fPlots; }
SkISize getSize() const;
private:
GrPlot* fPlots;
GrAtlasMgr* fAtlasMgr;

12
src/gpu/GrDistanceFieldTextContext.cpp
View File

@ -8,6 +8,7 @@
#include "GrDistanceFieldTextContext.h"
#include "GrAtlas.h"
#include "GrDrawTarget.h"
#include "GrDrawTargetCaps.h"
#include "GrFontScaler.h"
#include "SkGlyphCache.h"
#include "GrIndexBuffer.h"
@ -46,6 +47,7 @@ GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint) {
return !paint.getRasterizer() && !paint.getMaskFilter() &&
paint.getStyle() == SkPaint::kFill_Style &&
fContext->getTextTarget()->caps()->shaderDerivativeSupport() &&
!SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix());
}
@ -72,8 +74,9 @@ void GrDistanceFieldTextContext::flushGlyphs() {
GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
// This effect could be stored with one of the cache objects (atlas?)
SkISize size = fStrike->getAtlasSize();
drawState->addCoverageEffect(
GrDistanceFieldTextureEffect::Create(fCurrTexture, params),
GrDistanceFieldTextureEffect::Create(fCurrTexture, params, size),
kGlyphCoordsAttributeIndex)->unref();
if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
@ -263,22 +266,23 @@ HAS_ATLAS:
sy += dy;
width *= scale;
height *= scale;
GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
GrFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
GrFixed tw = SkIntToFixed(glyph->fBounds.width());
GrFixed th = SkIntToFixed(glyph->fBounds.height());
static const size_t kVertexSize = 2 * sizeof(SkPoint);
fVertices[2*fCurrVertex].setRectFan(sx,
sy,
sx + width,
sy + height,
2 * sizeof(SkPoint));
kVertexSize);
fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
SkFixedToFloat(texture->normalizeFixedY(ty)),
SkFixedToFloat(texture->normalizeFixedX(tx + tw)),
SkFixedToFloat(texture->normalizeFixedY(ty + th)),
2 * sizeof(SkPoint));
kVertexSize);
fCurrVertex += 4;
}

2
src/gpu/GrTextStrike.h
View File

@ -39,6 +39,8 @@ public:
inline GrGlyph* getGlyph(GrGlyph::PackedID, GrFontScaler*);
bool getGlyphAtlas(GrGlyph*, GrFontScaler*);
SkISize getAtlasSize() const { return fAtlas.getSize(); }
// testing
int countGlyphs() const { return fCache.getArray().count(); }
const GrGlyph* glyphAt(int index) const {

74
src/gpu/effects/GrDistanceFieldTextureEffect.cpp
View File

@ -13,14 +13,17 @@
#include "GrTBackendEffectFactory.h"
#include "GrTexture.h"
// The distance field is constructed as unsigned char values, so that the zero value is at 128.
// Hence our zero threshold is 128/255.
// The distance field is constructed as unsigned char values, so that the zero value is at 128,
// and the range is [-4, 4 - 1/255). Hence our multiplier is 8 - 1/32 and zero threshold is 128/255.
#define MULTIPLIER "7.96875"
#define THRESHOLD "0.50196078431"
class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect {
public:
GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory, const GrDrawEffect& drawEffect)
: INHERITED (factory) {}
GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
const GrDrawEffect& drawEffect)
: INHERITED (factory)
, fTextureSize(SkSize::Make(-1.f,-1.f)) {}
virtual void emitCode(GrGLFullShaderBuilder* builder,
const GrDrawEffect& drawEffect,
@ -31,43 +34,77 @@ public:
const TextureSamplerArray& samplers) SK_OVERRIDE {
SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
SkString fsCoordName;
const char* vsVaryingName;
const char* fsVaryingNamePtr;
builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsVaryingName, &fsVaryingNamePtr);
fsCoordName = fsVaryingNamePtr;
SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
const char* attrName =
SkString fsCoordName;
const char* vsCoordName;
const char* fsCoordNamePtr;
builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
fsCoordName = fsCoordNamePtr;
const char* attrName0 =
builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
builder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, attrName);
builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
const char* textureSizeUniName = NULL;
fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
kVec2f_GrSLType, "TextureSize",
&textureSizeUniName);
builder->fsCodeAppend("\tvec4 texColor = ");
builder->fsAppendTextureLookup(samplers[0],
fsCoordName.c_str(),
kVec2f_GrSLType);
builder->fsCodeAppend(";\n");
builder->fsCodeAppend("\tfloat distance = texColor.r;\n");
builder->fsCodeAppend("\tfloat distance = "MULTIPLIER"*(texColor.r - "THRESHOLD");\n");
// we adjust for the effect of the transformation on the distance by using
// the length of the gradient of the texture coordinates. We use st coordinates
// to ensure we're mapping 1:1 from texel space to pixel space.
builder->fsCodeAppendf("\tvec2 st = %s*%s;\n", fsCoordName.c_str(), textureSizeUniName);
builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
builder->fsCodeAppend("\tvec2 st_grad = normalize(st);\n");
builder->fsCodeAppend("\tvec2 grad = vec2(st_grad.x*Jdx.x + st_grad.y*Jdy.x,\n");
builder->fsCodeAppend("\t st_grad.x*Jdx.y + st_grad.y*Jdy.y);\n");
// this gives us a smooth step across approximately one fragment
// (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
builder->fsCodeAppend("\tfloat afwidth = 0.7071*length(vec2(dFdx(distance), dFdy(distance)));\n");
builder->fsCodeAppend("\tfloat val = smoothstep("THRESHOLD"-afwidth, "THRESHOLD"+afwidth, distance);\n");
builder->fsCodeAppend("\tfloat afwidth = 0.7071*length(grad);\n");
builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
}
virtual void setData(const GrGLUniformManager& uman,
const GrDrawEffect& drawEffect) SK_OVERRIDE {}
const GrDrawEffect& drawEffect) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
const GrDistanceFieldTextureEffect& distanceFieldEffect =
drawEffect.castEffect<GrDistanceFieldTextureEffect>();
if (distanceFieldEffect.getSize().width() != fTextureSize.width() ||
distanceFieldEffect.getSize().height() != fTextureSize.height()) {
fTextureSize = distanceFieldEffect.getSize();
uman.set2f(fTextureSizeUni,
distanceFieldEffect.getSize().width(),
distanceFieldEffect.getSize().height());
}
}
private:
GrGLUniformManager::UniformHandle fTextureSizeUni;
SkSize fTextureSize;
typedef GrGLVertexEffect INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
const GrTextureParams& params)
: fTextureAccess(texture, params) {
const GrTextureParams& params,
const SkISize& size)
: fTextureAccess(texture, params)
, fSize(SkSize::Make(SkIntToScalar(size.width()), SkIntToScalar(size.height()))) {
this->addTextureAccess(&fTextureAccess);
this->addVertexAttrib(kVec2f_GrSLType);
}
@ -112,6 +149,7 @@ GrEffectRef* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
};
GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
GrTextureParams::kNone_FilterMode);
SkISize size = SkISize::Make(1024, 2048);
return GrDistanceFieldTextureEffect::Create(textures[texIdx], params);
return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, size);
}

11
src/gpu/effects/GrDistanceFieldTextureEffect.h
View File

@ -21,27 +21,30 @@ class GrGLDistanceFieldTextureEffect;
*/
class GrDistanceFieldTextureEffect : public GrVertexEffect {
public:
static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& p) {
AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldTextureEffect, (tex, p)));
static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& p, const SkISize& s) {
AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldTextureEffect, (tex, p, s)));
return CreateEffectRef(effect);
}
virtual ~GrDistanceFieldTextureEffect() {}
static const char* Name() { return "Texture"; }
static const char* Name() { return "DistanceFieldTexture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
const SkSize& getSize() const { return fSize; }
typedef GrGLDistanceFieldTextureEffect GLEffect;
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
GrDistanceFieldTextureEffect(GrTexture* texture, const GrTextureParams& params);
GrDistanceFieldTextureEffect(GrTexture* texture, const GrTextureParams& params,
const SkISize& textureSize);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
SkSize fSize;
GR_DECLARE_EFFECT_TEST;