Revert of Gamma correction for distance field text. (https://codereview.chromium.org/258883002/)
Reason for revert:
Memory leaks. I suspect this is due to the lack of destructors in SkAutoGlyphCache
Original issue's description:
> Gamma correction for distance field text.
>
> Handles both non-LCD and LCD text. Uses a texture to look up the gamma correction values for a given text color or luminance.
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/4d517fdbb145cb95e5e935470df331e1b6667cfc
NOTRY=true
NOTREECHECKS=true
R=reed@google.com, bungeman@google.com, robertphillips@google.com, bsalomon@google.com, jvanverth@google.com, mtklein@google.com
Author: scroggo@google.com
Review URL: https://codereview.chromium.org/323513005
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index f766ca1..95fc0b8 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -1081,8 +1081,7 @@
SkScalar measure_text(SkGlyphCache*, const char* text, size_t length,
int* count, SkRect* bounds) const;
- SkGlyphCache* detachCache(const SkDeviceProperties* deviceProperties, const SkMatrix*,
- bool ignoreGamma) const;
+ SkGlyphCache* detachCache(const SkDeviceProperties* deviceProperties, const SkMatrix*) const;
void descriptorProc(const SkDeviceProperties* deviceProperties, const SkMatrix* deviceMatrix,
void (*proc)(SkTypeface*, const SkDescriptor*, void*),
@@ -1132,7 +1131,6 @@
}
friend class SkAutoGlyphCache;
- friend class SkAutoGlyphCacheNoGamma;
friend class SkCanvas;
friend class SkDraw;
friend class SkGraphics; // So Term() can be called.
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index d18b61a..8b404dc 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -244,8 +244,23 @@
friend class SkGlyphCache_Globals;
};
-class SkAutoGlyphCacheBase {
+class SkAutoGlyphCache {
public:
+ SkAutoGlyphCache(SkGlyphCache* cache) : fCache(cache) {}
+ SkAutoGlyphCache(SkTypeface* typeface, const SkDescriptor* desc) {
+ fCache = SkGlyphCache::DetachCache(typeface, desc);
+ }
+ SkAutoGlyphCache(const SkPaint& paint,
+ const SkDeviceProperties* deviceProperties,
+ const SkMatrix* matrix) {
+ fCache = paint.detachCache(deviceProperties, matrix);
+ }
+ ~SkAutoGlyphCache() {
+ if (fCache) {
+ SkGlyphCache::AttachCache(fCache);
+ }
+ }
+
SkGlyphCache* getCache() const { return fCache; }
void release() {
@@ -255,61 +270,11 @@
}
}
-protected:
- // Hide the constructors so we can't create one of these directly.
- // Create SkAutoGlyphCache or SkAutoGlyphCacheNoCache instead.
- SkAutoGlyphCacheBase(SkGlyphCache* cache) : fCache(cache) {}
- SkAutoGlyphCacheBase(SkTypeface* typeface, const SkDescriptor* desc) {
- fCache = SkGlyphCache::DetachCache(typeface, desc);
- }
- SkAutoGlyphCacheBase(const SkPaint& paint,
- const SkDeviceProperties* deviceProperties,
- const SkMatrix* matrix) {
- fCache = NULL;
- }
- SkAutoGlyphCacheBase() {}
-
+private:
SkGlyphCache* fCache;
-private:
static bool DetachProc(const SkGlyphCache*, void*);
};
-
-class SkAutoGlyphCache : public SkAutoGlyphCacheBase {
-public:
- SkAutoGlyphCache(SkGlyphCache* cache) : SkAutoGlyphCacheBase(cache) {}
- SkAutoGlyphCache(SkTypeface* typeface, const SkDescriptor* desc) :
- SkAutoGlyphCacheBase(typeface, desc) {}
- SkAutoGlyphCache(const SkPaint& paint,
- const SkDeviceProperties* deviceProperties,
- const SkMatrix* matrix) {
- fCache = paint.detachCache(deviceProperties, matrix, false);
- }
- SkAutoGlyphCache() : SkAutoGlyphCacheBase() {
- if (fCache) {
- SkGlyphCache::AttachCache(fCache);
- }
- }
-};
#define SkAutoGlyphCache(...) SK_REQUIRE_LOCAL_VAR(SkAutoGlyphCache)
-class SkAutoGlyphCacheNoGamma : public SkAutoGlyphCacheBase {
-public:
- SkAutoGlyphCacheNoGamma(SkGlyphCache* cache) : SkAutoGlyphCacheBase(cache) {}
- SkAutoGlyphCacheNoGamma(SkTypeface* typeface, const SkDescriptor* desc) :
- SkAutoGlyphCacheBase(typeface, desc) {}
- SkAutoGlyphCacheNoGamma(const SkPaint& paint,
- const SkDeviceProperties* deviceProperties,
- const SkMatrix* matrix) {
- fCache = paint.detachCache(deviceProperties, matrix, true);
- }
- SkAutoGlyphCacheNoGamma() : SkAutoGlyphCacheBase() {
- if (fCache) {
- SkGlyphCache::AttachCache(fCache);
- }
- }
-};
-#define SkAutoGlyphCacheNoGamma(...) SK_REQUIRE_LOCAL_VAR(SkAutoGlyphCacheNoGamma)
-
-
#endif
diff --git a/src/core/SkMaskGamma.h b/src/core/SkMaskGamma.h
index 08ed97f..1f2b73c 100644
--- a/src/core/SkMaskGamma.h
+++ b/src/core/SkMaskGamma.h
@@ -136,22 +136,6 @@
*/
PreBlend preBlend(SkColor color) const;
- /**
- * Get dimensions for the full table set, so it can be allocated as a block.
- */
- void getGammaTableDimensions(int* tableWidth, int* numTables) const {
- *tableWidth = 256;
- *numTables = (1 << MAX_LUM_BITS);
- }
-
- /**
- * Provides direct access to the full table set, so it can be uploaded
- * into a texture.
- */
- const uint8_t* getGammaTables() const {
- return (const uint8_t*) fGammaTables;
- }
-
private:
static const int MAX_LUM_BITS =
B_LUM_BITS > (R_LUM_BITS > G_LUM_BITS ? R_LUM_BITS : G_LUM_BITS)
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index b08b2c6..78d9470 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -1814,8 +1814,10 @@
/*
* ignoreGamma tells us that the caller just wants metrics that are unaffected
- * by gamma correction, so we set the rec to ignore preblend: i.e. gamma = 1,
- * contrast = 0, luminanceColor = transparent black.
+ * by gamma correction, so we jam the luminance field to 0 (most common value
+ * for black text) in hopes that we get a cache hit easier. A better solution
+ * would be for the fontcache lookup to know to ignore the luminance field
+ * entirely, but not sure how to do that and keep it fast.
*/
void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
const SkMatrix* deviceMatrix,
@@ -1825,7 +1827,7 @@
SkScalerContext::MakeRec(*this, deviceProperties, deviceMatrix, &rec);
if (ignoreGamma) {
- rec.ignorePreBlend();
+ rec.setLuminanceColor(0);
}
size_t descSize = sizeof(rec);
@@ -1949,10 +1951,9 @@
}
SkGlyphCache* SkPaint::detachCache(const SkDeviceProperties* deviceProperties,
- const SkMatrix* deviceMatrix,
- bool ignoreGamma) const {
+ const SkMatrix* deviceMatrix) const {
SkGlyphCache* cache;
- this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, ignoreGamma);
+ this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, false);
return cache;
}
@@ -1968,33 +1969,6 @@
return maskGamma.preBlend(rec.getLuminanceColor());
}
-size_t SkScalerContext::GetGammaLUTSize(SkScalar contrast, SkScalar paintGamma,
- SkScalar deviceGamma, int* width, int* height) {
- SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
- const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
- paintGamma,
- deviceGamma);
-
- maskGamma.getGammaTableDimensions(width, height);
- size_t size = (*width)*(*height)*sizeof(uint8_t);
-
- return size;
-}
-
-void SkScalerContext::GetGammaLUTData(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma,
- void* data) {
- SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
- const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
- paintGamma,
- deviceGamma);
- int width, height;
- maskGamma.getGammaTableDimensions(&width, &height);
- size_t size = width*height*sizeof(uint8_t);
- const uint8_t* gammaTables = maskGamma.getGammaTables();
- memcpy(data, gammaTables, size);
-}
-
-
///////////////////////////////////////////////////////////////////////////////
#include "SkStream.h"
@@ -2583,7 +2557,7 @@
fPaint.setPathEffect(NULL);
}
- fCache = fPaint.detachCache(NULL, NULL, false);
+ fCache = fPaint.detachCache(NULL, NULL);
SkPaint::Style style = SkPaint::kFill_Style;
SkPathEffect* pe = NULL;
diff --git a/src/core/SkScalerContext.h b/src/core/SkScalerContext.h
index af83685..f18d217 100644
--- a/src/core/SkScalerContext.h
+++ b/src/core/SkScalerContext.h
@@ -184,17 +184,6 @@
void getPath(const SkGlyph&, SkPath*);
void getFontMetrics(SkPaint::FontMetrics*);
- /** Return the size in bytes of the associated gamma lookup table
- */
- static size_t GetGammaLUTSize(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma,
- int* width, int* height);
-
- /** Get the associated gamma lookup table. The 'data' pointer must point to pre-allocated
- memory, with size in bytes greater than or equal to the return value of getGammaLUTSize().
- */
- static void GetGammaLUTData(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma,
- void* data);
-
#ifdef SK_BUILD_FOR_ANDROID
unsigned getBaseGlyphCount(SkUnichar charCode);
diff --git a/src/gpu/GrDistanceFieldTextContext.cpp b/src/gpu/GrDistanceFieldTextContext.cpp
index a729939..2d2f9a1 100755
--- a/src/gpu/GrDistanceFieldTextContext.cpp
+++ b/src/gpu/GrDistanceFieldTextContext.cpp
@@ -7,12 +7,10 @@
#include "GrDistanceFieldTextContext.h"
#include "GrAtlas.h"
-#include "SkColorFilter.h"
#include "GrDrawTarget.h"
#include "GrDrawTargetCaps.h"
#include "GrFontScaler.h"
#include "SkGlyphCache.h"
-#include "GrGpu.h"
#include "GrIndexBuffer.h"
#include "GrTextStrike.h"
#include "GrTextStrike_impl.h"
@@ -45,7 +43,6 @@
fEnableDFRendering = enable;
#endif
fStrike = NULL;
- fGammaTexture = NULL;
fCurrTexture = NULL;
fCurrVertex = 0;
@@ -56,7 +53,6 @@
GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
this->flushGlyphs();
- SkSafeSetNull(fGammaTexture);
}
bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint) {
@@ -111,26 +107,14 @@
SkASSERT(SkIsAlign4(fCurrVertex));
SkASSERT(fCurrTexture);
GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
- GrTextureParams gammaParams(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
// Effects could be stored with one of the cache objects (atlas?)
- SkColor filteredColor;
- SkColorFilter* colorFilter = fSkPaint.getColorFilter();
- if (NULL != colorFilter) {
- filteredColor = colorFilter->filterColor(fSkPaint.getColor());
- } else {
- filteredColor = fSkPaint.getColor();
- }
if (fUseLCDText) {
- GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);
bool useBGR = SkDeviceProperties::Geometry::kBGR_Layout ==
fDeviceProperties.fGeometry.getLayout();
drawState->addCoverageEffect(GrDistanceFieldLCDTextureEffect::Create(
fCurrTexture,
params,
- fGammaTexture,
- gammaParams,
- colorNoPreMul,
fContext->getMatrix().rectStaysRect() &&
fContext->getMatrix().isSimilarity(),
useBGR),
@@ -149,24 +133,13 @@
// paintAlpha
drawState->setColor(SkColorSetARGB(a, a, a, a));
// paintColor
- drawState->setBlendConstant(colorNoPreMul);
+ drawState->setBlendConstant(skcolor_to_grcolor_nopremultiply(fSkPaint.getColor()));
drawState->setBlendFunc(kConstC_GrBlendCoeff, kISC_GrBlendCoeff);
} else {
-#ifdef SK_GAMMA_APPLY_TO_A8
- U8CPU lum = SkColorSpaceLuminance::computeLuminance(fDeviceProperties.fGamma,
- filteredColor);
- drawState->addCoverageEffect(GrDistanceFieldTextureEffect::Create(
- fCurrTexture, params,
- fGammaTexture, gammaParams,
- lum/255.f,
+ drawState->addCoverageEffect(GrDistanceFieldTextureEffect::Create(fCurrTexture, params,
fContext->getMatrix().isSimilarity()),
kGlyphCoordsAttributeIndex)->unref();
-#else
- drawState->addCoverageEffect(GrDistanceFieldTextureEffect::Create(
- fCurrTexture, params,
- fContext->getMatrix().isSimilarity()),
- kGlyphCoordsAttributeIndex)->unref();
-#endif
+
// set back to normal in case we took LCD path previously.
drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
drawState->setColor(fPaint.getColor());
@@ -383,9 +356,7 @@
fSkPaint.setLCDRenderText(false);
fSkPaint.setAutohinted(false);
- fSkPaint.setHinting(SkPaint::kNormal_Hinting);
fSkPaint.setSubpixelText(true);
-
}
inline void GrDistanceFieldTextContext::finish() {
@@ -394,46 +365,6 @@
GrTextContext::finish();
}
-static void setup_gamma_texture(GrContext* context, const SkGlyphCache* cache,
- const SkDeviceProperties& deviceProperties,
- GrTexture** gammaTexture) {
- if (NULL == *gammaTexture) {
- int width, height;
- size_t size;
-
-#ifdef SK_GAMMA_CONTRAST
- SkScalar contrast = SK_GAMMA_CONTRAST;
-#else
- SkScalar contrast = 0.5f;
-#endif
- SkScalar paintGamma = deviceProperties.fGamma;
- SkScalar deviceGamma = deviceProperties.fGamma;
-
- size = SkScalerContext::GetGammaLUTSize(contrast, paintGamma, deviceGamma,
- &width, &height);
-
- SkAutoTArray<uint8_t> data((int)size);
- SkScalerContext::GetGammaLUTData(contrast, paintGamma, deviceGamma, data.get());
-
- // TODO: Update this to use the cache rather than directly creating a texture.
- GrTextureDesc desc;
- desc.fFlags = kDynamicUpdate_GrTextureFlagBit;
- desc.fWidth = width;
- desc.fHeight = height;
- desc.fConfig = kAlpha_8_GrPixelConfig;
-
- *gammaTexture = context->getGpu()->createTexture(desc, NULL, 0);
- if (NULL == *gammaTexture) {
- return;
- }
-
- context->writeTexturePixels(*gammaTexture,
- 0, 0, width, height,
- (*gammaTexture)->config(), data.get(), 0,
- GrContext::kDontFlush_PixelOpsFlag);
- }
-}
-
void GrDistanceFieldTextContext::drawText(const GrPaint& paint, const SkPaint& skPaint,
const char text[], size_t byteLength,
SkScalar x, SkScalar y) {
@@ -451,11 +382,9 @@
SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
- SkAutoGlyphCacheNoGamma autoCache(fSkPaint, &fDeviceProperties, NULL);
- SkGlyphCache* cache = autoCache.getCache();
- GrFontScaler* fontScaler = GetGrFontScaler(cache);
-
- setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
+ SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, NULL);
+ SkGlyphCache* cache = autoCache.getCache();
+ GrFontScaler* fontScaler = GetGrFontScaler(cache);
// need to measure first
// TODO - generate positions and pre-load cache as well?
@@ -526,11 +455,9 @@
SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
- SkAutoGlyphCacheNoGamma autoCache(fSkPaint, &fDeviceProperties, NULL);
- SkGlyphCache* cache = autoCache.getCache();
- GrFontScaler* fontScaler = GetGrFontScaler(cache);
-
- setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
+ SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, NULL);
+ SkGlyphCache* cache = autoCache.getCache();
+ GrFontScaler* fontScaler = GetGrFontScaler(cache);
const char* stop = text + byteLength;
diff --git a/src/gpu/GrDistanceFieldTextContext.h b/src/gpu/GrDistanceFieldTextContext.h
index 3a602f0..3dfffd1 100644
--- a/src/gpu/GrDistanceFieldTextContext.h
+++ b/src/gpu/GrDistanceFieldTextContext.h
@@ -34,7 +34,6 @@
SkScalar fTextRatio;
bool fUseLCDText;
bool fEnableDFRendering;
- GrTexture* fGammaTexture;
void init(const GrPaint&, const SkPaint&);
void drawPackedGlyph(GrGlyph::PackedID, SkFixed left, SkFixed top, GrFontScaler*);
diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
index 29f0985..6196cce 100755
--- a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
+++ b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
@@ -15,19 +15,6 @@
#include "SkDistanceFieldGen.h"
-// To get optical sizes people don't complain about when we blit correctly,
-// we need to slightly bold each glyph. On the Mac, we need a larger bold value.
-#if defined(SK_BUILD_FOR_MAC)
-#define SK_DistanceFieldLCDFactor "0.33"
-#define SK_DistanceFieldNonLCDFactor "0.25"
-#else
-#define SK_DistanceFieldLCDFactor "0.05"
-#define SK_DistanceFieldNonLCDFactor "0.05"
-#endif
-
-// Assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2
-#define SK_DistanceFieldAAFactor "0.7071"
-
class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect {
public:
GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
@@ -69,8 +56,7 @@
kVec2f_GrSLType);
builder->fsCodeAppend(";\n");
builder->fsCodeAppend("\tfloat distance = "
- SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ")"
- "+ " SK_DistanceFieldNonLCDFactor ";\n");
+ SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");\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
@@ -80,7 +66,8 @@
builder->fsCodeAppend("\tfloat afwidth;\n");
if (dfTexEffect.isSimilarity()) {
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dFdx(st.x);\n");
+ // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+ builder->fsCodeAppend("\tafwidth = 0.7071*dFdx(st.x);\n");
} else {
builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
@@ -101,25 +88,12 @@
builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
+ // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+ builder->fsCodeAppend("\tafwidth = 0.7071*length(grad);\n");
}
+
builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
-#ifdef SK_GAMMA_APPLY_TO_A8
- // adjust based on gamma
- const char* luminanceUniName = NULL;
- // width, height, 1/(3*width)
- fLuminanceUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
- kFloat_GrSLType, "Luminance",
- &luminanceUniName);
-
- builder->fsCodeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName);
- builder->fsCodeAppend("\tvec4 gammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval = gammaColor.r;\n");
-#endif
-
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
}
@@ -136,15 +110,6 @@
SkIntToScalar(fTextureSize.width()),
SkIntToScalar(fTextureSize.height()));
}
-#ifdef SK_GAMMA_APPLY_TO_A8
- const GrDistanceFieldTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldTextureEffect>();
- float luminance = dfTexEffect.getLuminance();
- if (luminance != fLuminance) {
- uman.set1f(fLuminanceUni, luminance);
- fLuminance = luminance;
- }
-#endif
}
static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
@@ -157,8 +122,6 @@
private:
GrGLUniformManager::UniformHandle fTextureSizeUni;
SkISize fTextureSize;
- GrGLUniformManager::UniformHandle fLuminanceUni;
- float fLuminance;
typedef GrGLVertexEffect INHERITED;
};
@@ -167,22 +130,10 @@
GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
const GrTextureParams& params,
-#ifdef SK_GAMMA_APPLY_TO_A8
- GrTexture* gamma,
- const GrTextureParams& gammaParams,
- float luminance,
-#endif
bool similarity)
: fTextureAccess(texture, params)
-#ifdef SK_GAMMA_APPLY_TO_A8
- , fGammaTextureAccess(gamma, gammaParams)
- , fLuminance(luminance)
-#endif
, fIsSimilarity(similarity) {
this->addTextureAccess(&fTextureAccess);
-#ifdef SK_GAMMA_APPLY_TO_A8
- this->addTextureAccess(&fGammaTextureAccess);
-#endif
this->addVertexAttrib(kVec2f_GrSLType);
}
@@ -215,10 +166,6 @@
GrTexture* textures[]) {
int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
GrEffectUnitTest::kAlphaTextureIdx;
-#ifdef SK_GAMMA_APPLY_TO_A8
- int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
-#endif
static const SkShader::TileMode kTileModes[] = {
SkShader::kClamp_TileMode,
SkShader::kRepeat_TileMode,
@@ -230,16 +177,8 @@
};
GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
GrTextureParams::kNone_FilterMode);
-#ifdef SK_GAMMA_APPLY_TO_A8
- GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
- GrTextureParams::kNone_FilterMode);
-#endif
return GrDistanceFieldTextureEffect::Create(textures[texIdx], params,
-#ifdef SK_GAMMA_APPLY_TO_A8
- textures[texIdx2], params2,
- random->nextF(),
-#endif
random->nextBool());
}
@@ -272,7 +211,7 @@
fsCoordName = fsCoordNamePtr;
const char* attrName0 =
- builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
+ builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
const char* textureSizeUniName = NULL;
@@ -298,24 +237,22 @@
builder->fsAppendTextureLookup(samplers[0], "uv", kVec2f_GrSLType);
builder->fsCodeAppend(";\n");
builder->fsCodeAppend("\tvec3 distance;\n");
- builder->fsCodeAppend("\tdistance.y = texColor.r;\n");
+ builder->fsCodeAppend("\tdistance.y = "
+ SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");\n");
// red is distance to left offset
builder->fsCodeAppend("\tvec2 uv_adjusted = uv - offset;\n");
builder->fsCodeAppend("\ttexColor = ");
builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tdistance.x = texColor.r;\n");
+ builder->fsCodeAppend("\tdistance.x = "
+ SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");\n");
// blue is distance to right offset
builder->fsCodeAppend("\tuv_adjusted = uv + offset;\n");
builder->fsCodeAppend("\ttexColor = ");
builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tdistance.z = texColor.r;\n");
-
- builder->fsCodeAppend("\tdistance = "
- "vec3(" SK_DistanceFieldMultiplier ")*(distance - vec3(" SK_DistanceFieldThreshold"))"
- "+ vec3(" SK_DistanceFieldLCDFactor ");\n");
-
+ builder->fsCodeAppend("\tdistance.z = "
+ SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");\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.
@@ -327,7 +264,8 @@
builder->fsCodeAppend("\tfloat afwidth;\n");
if (dfTexEffect.isUniformScale()) {
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dx;\n");
+ // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+ builder->fsCodeAppend("\tafwidth = 0.7071*dx;\n");
} else {
builder->fsCodeAppend("\tvec2 uv_grad;\n");
if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
@@ -345,36 +283,12 @@
builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
+ // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
+ builder->fsCodeAppend("\tafwidth = 0.7071*length(grad);\n");
}
builder->fsCodeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n");
- // adjust based on gamma
- const char* textColorUniName = NULL;
- // width, height, 1/(3*width)
- fTextColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
- kVec3f_GrSLType, "TextColor",
- &textColorUniName);
-
- builder->fsCodeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName);
- builder->fsCodeAppend("\tvec4 gammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.x = gammaColor.r;\n");
-
- builder->fsCodeAppendf("\tuv = vec2(val.y, %s.y);\n", textColorUniName);
- builder->fsCodeAppend("\tgammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.y = gammaColor.r;\n");
-
- builder->fsCodeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName);
- builder->fsCodeAppend("\tgammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.z = gammaColor.r;\n");
-
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr4("val")).c_str());
}
@@ -382,13 +296,12 @@
virtual void setData(const GrGLUniformManager& uman,
const GrDrawEffect& drawEffect) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
- SkASSERT(fTextColorUni.isValid());
- const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
GrTexture* texture = drawEffect.effect()->get()->texture(0);
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
+ const GrDistanceFieldLCDTextureEffect& dfTexEffect =
+ drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
fTextureSize = SkISize::Make(texture->width(), texture->height());
float delta = 1.0f/(3.0f*texture->width());
if (dfTexEffect.useBGR()) {
@@ -399,55 +312,40 @@
SkIntToScalar(fTextureSize.height()),
delta);
}
-
- GrColor textColor = dfTexEffect.getTextColor();
- if (textColor != fTextColor) {
- static const float ONE_OVER_255 = 1.f / 255.f;
- uman.set3f(fTextColorUni,
- GrColorUnpackR(textColor) * ONE_OVER_255,
- GrColorUnpackG(textColor) * ONE_OVER_255,
- GrColorUnpackB(textColor) * ONE_OVER_255);
- fTextColor = textColor;
- }
}
static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
- return dfTexEffect.isUniformScale() ? 0x01 : 0x00;;
+ int uniformScale = dfTexEffect.isUniformScale() ? 0x01 : 0x00;
+ int useBGR = dfTexEffect.useBGR() ? 0x10 : 0x00;
+ return uniformScale | useBGR;
}
private:
GrGLUniformManager::UniformHandle fTextureSizeUni;
SkISize fTextureSize;
- GrGLUniformManager::UniformHandle fTextColorUni;
- SkColor fTextColor;
typedef GrGLVertexEffect INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
-GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(
- GrTexture* texture, const GrTextureParams& params,
- GrTexture* gamma, const GrTextureParams& gParams,
- SkColor textColor,
- bool uniformScale, bool useBGR)
+GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(GrTexture* texture,
+ const GrTextureParams& params,
+ bool uniformScale,
+ bool useBGR)
: fTextureAccess(texture, params)
- , fGammaTextureAccess(gamma, gParams)
- , fTextColor(textColor)
, fUniformScale(uniformScale)
, fUseBGR(useBGR) {
this->addTextureAccess(&fTextureAccess);
- this->addTextureAccess(&fGammaTextureAccess);
this->addVertexAttrib(kVec2f_GrSLType);
}
bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrDistanceFieldLCDTextureEffect& cte =
- CastEffect<GrDistanceFieldLCDTextureEffect>(other);
- return (fTextureAccess == cte.fTextureAccess && fGammaTextureAccess == cte.fGammaTextureAccess);
+ const GrDistanceFieldLCDTextureEffect& cte = CastEffect<GrDistanceFieldLCDTextureEffect>(other);
+ return fTextureAccess == cte.fTextureAccess;
}
void GrDistanceFieldLCDTextureEffect::getConstantColorComponents(GrColor* color,
@@ -473,9 +371,7 @@
const GrDrawTargetCaps&,
GrTexture* textures[]) {
int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
- int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
+ GrEffectUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
SkShader::kClamp_TileMode,
SkShader::kRepeat_TileMode,
@@ -487,14 +383,7 @@
};
GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
GrTextureParams::kNone_FilterMode);
- GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
- GrTextureParams::kNone_FilterMode);
- GrColor textColor = GrColorPackRGBA(random->nextULessThan(256),
- random->nextULessThan(256),
- random->nextULessThan(256),
- random->nextULessThan(256));
+
return GrDistanceFieldLCDTextureEffect::Create(textures[texIdx], params,
- textures[texIdx2], params2,
- textColor,
random->nextBool(), random->nextBool());
}
diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.h b/src/gpu/effects/GrDistanceFieldTextureEffect.h
index 692290c..937908f 100644
--- a/src/gpu/effects/GrDistanceFieldTextureEffect.h
+++ b/src/gpu/effects/GrDistanceFieldTextureEffect.h
@@ -18,23 +18,12 @@
* The output color of this effect is a modulation of the input color and a sample from a
* distance field texture (using a smoothed step function near 0.5).
* It allows explicit specification of the filtering and wrap modes (GrTextureParams). The input
- * coords are a custom attribute. Gamma correction is handled via a texture LUT.
+ * coords are a custom attribute.
*/
class GrDistanceFieldTextureEffect : public GrVertexEffect {
public:
-#ifdef SK_GAMMA_APPLY_TO_A8
- static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& params,
- GrTexture* gamma, const GrTextureParams& gammaParams, float lum,
- bool similarity) {
- AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldTextureEffect, (tex, params,
- gamma, gammaParams, lum,
- similarity)));
-#else
- static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& params,
- bool similarity) {
- AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldTextureEffect, (tex, params,
- similarity)));
-#endif
+ static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& params, bool similarity) {
+ AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldTextureEffect, (tex, params, similarity)));
return CreateEffectRef(effect);
}
@@ -43,9 +32,6 @@
static const char* Name() { return "DistanceFieldTexture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
-#ifdef SK_GAMMA_APPLY_TO_A8
- float getLuminance() const { return fLuminance; }
-#endif
bool isSimilarity() const { return fIsSimilarity; }
typedef GrGLDistanceFieldTextureEffect GLEffect;
@@ -54,18 +40,11 @@
private:
GrDistanceFieldTextureEffect(GrTexture* texture, const GrTextureParams& params,
-#ifdef SK_GAMMA_APPLY_TO_A8
- GrTexture* gamma, const GrTextureParams& gammaParams, float lum,
-#endif
bool uniformScale);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
-#ifdef SK_GAMMA_APPLY_TO_A8
- GrTextureAccess fGammaTextureAccess;
- float fLuminance;
-#endif
bool fIsSimilarity;
GR_DECLARE_EFFECT_TEST;
@@ -77,17 +56,14 @@
* The output color of this effect is a modulation of the input color and samples from a
* distance field texture (using a smoothed step function near 0.5), adjusted for LCD displays.
* It allows explicit specification of the filtering and wrap modes (GrTextureParams). The input
- * coords are a custom attribute. Gamma correction is handled via a texture LUT.
+ * coords are a custom attribute.
*/
class GrDistanceFieldLCDTextureEffect : public GrVertexEffect {
public:
static GrEffectRef* Create(GrTexture* tex, const GrTextureParams& params,
- GrTexture* gamma, const GrTextureParams& gammaParams,
- SkColor textColor,
bool uniformScale, bool useBGR) {
AutoEffectUnref effect(SkNEW_ARGS(GrDistanceFieldLCDTextureEffect,
- (tex, params, gamma, gammaParams, textColor, uniformScale,
- useBGR)));
+ (tex, params, uniformScale, useBGR)));
return CreateEffectRef(effect);
}
@@ -96,7 +72,6 @@
static const char* Name() { return "DistanceFieldLCDTexture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
- GrColor getTextColor() const { return fTextColor; }
bool isUniformScale() const { return fUniformScale; }
bool useBGR() const { return fUseBGR; }
@@ -106,15 +81,11 @@
private:
GrDistanceFieldLCDTextureEffect(GrTexture* texture, const GrTextureParams& params,
- GrTexture* gamma, const GrTextureParams& gammaParams,
- SkColor textColor,
bool uniformScale, bool useBGR);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
- GrTextureAccess fGammaTextureAccess;
- GrColor fTextColor;
bool fUniformScale;
bool fUseBGR;
@@ -123,4 +94,5 @@
typedef GrVertexEffect INHERITED;
};
+
#endif