X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fthird_party%2Fskia%2Fsrc%2Fgpu%2Feffects%2FGrDistanceFieldTextureEffect.cpp;h=6196cce3298461b6d577abca697b6e257469f5a7;hb=004985e17e624662a4c85c76a7654039dc83f028;hp=dd370b6d4e66e32e37ff4f638c50d66015be1087;hpb=2f108dbacb161091e42a3479f4e171339b7e7623;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/third_party/skia/src/gpu/effects/GrDistanceFieldTextureEffect.cpp b/src/third_party/skia/src/gpu/effects/GrDistanceFieldTextureEffect.cpp index dd370b6..6196cce 100755 --- a/src/third_party/skia/src/gpu/effects/GrDistanceFieldTextureEffect.cpp +++ b/src/third_party/skia/src/gpu/effects/GrDistanceFieldTextureEffect.cpp @@ -13,10 +13,7 @@ #include "GrTBackendEffectFactory.h" #include "GrTexture.h" -// 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" +#include "SkDistanceFieldGen.h" class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect { public: @@ -58,7 +55,8 @@ public: fsCoordName.c_str(), kVec2f_GrSLType); builder->fsCodeAppend(";\n"); - builder->fsCodeAppend("\tfloat distance = " MULTIPLIER "*(texColor.r - " THRESHOLD ");\n"); + builder->fsCodeAppend("\tfloat distance = " + 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 @@ -66,7 +64,7 @@ public: builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str()); builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName); builder->fsCodeAppend("\tfloat afwidth;\n"); - if (dfTexEffect.isUniformScale()) { + if (dfTexEffect.isSimilarity()) { // 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("\tafwidth = 0.7071*dFdx(st.x);\n"); @@ -118,7 +116,7 @@ public: const GrDistanceFieldTextureEffect& dfTexEffect = drawEffect.castEffect(); - return dfTexEffect.isUniformScale() ? 0x1 : 0x0; + return dfTexEffect.isSimilarity() ? 0x1 : 0x0; } private: @@ -132,9 +130,9 @@ private: GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture, const GrTextureParams& params, - bool uniformScale) + bool similarity) : fTextureAccess(texture, params) - , fUniformScale(uniformScale) { + , fIsSimilarity(similarity) { this->addTextureAccess(&fTextureAccess); this->addVertexAttrib(kVec2f_GrSLType); } @@ -180,5 +178,212 @@ GrEffectRef* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random, GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : GrTextureParams::kNone_FilterMode); - return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, random->nextBool()); + return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, + random->nextBool()); +} + +/////////////////////////////////////////////////////////////////////////////// + +class GrGLDistanceFieldLCDTextureEffect : public GrGLVertexEffect { +public: + GrGLDistanceFieldLCDTextureEffect(const GrBackendEffectFactory& factory, + const GrDrawEffect& drawEffect) + : INHERITED (factory) + , fTextureSize(SkISize::Make(-1,-1)) {} + + virtual void emitCode(GrGLFullShaderBuilder* builder, + const GrDrawEffect& drawEffect, + EffectKey key, + const char* outputColor, + const char* inputColor, + const TransformedCoordsArray&, + const TextureSamplerArray& samplers) SK_OVERRIDE { + SkASSERT(1 == drawEffect.castEffect().numVertexAttribs()); + + SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); + const GrDistanceFieldLCDTextureEffect& dfTexEffect = + drawEffect.castEffect(); + + 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", vsCoordName, attrName0); + + const char* textureSizeUniName = NULL; + // width, height, 1/(3*width) + fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, + kVec3f_GrSLType, "TextureSize", + &textureSizeUniName); + + // create LCD offset adjusted by inverse of transform + builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str()); + builder->fsCodeAppendf("\tvec2 st = uv*%s.xy;\n", textureSizeUniName); + if (dfTexEffect.isUniformScale()) { + builder->fsCodeAppend("\tfloat dx = dFdx(st.x);\n"); + builder->fsCodeAppendf("\tvec2 offset = vec2(dx*%s.z, 0.0);\n", textureSizeUniName); + } else { + builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n"); + builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n"); + builder->fsCodeAppendf("\tvec2 offset = %s.z*Jdx;\n", textureSizeUniName); + } + + // green is distance to uv center + builder->fsCodeAppend("\tvec4 texColor = "); + builder->fsAppendTextureLookup(samplers[0], "uv", kVec2f_GrSLType); + builder->fsCodeAppend(";\n"); + builder->fsCodeAppend("\tvec3 distance;\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 = " + 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 = " + 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. + + // To be strictly correct, we should compute the anti-aliasing factor separately + // for each color component. However, this is only important when using perspective + // transformations, and even then using a single factor seems like a reasonable + // trade-off between quality and speed. + builder->fsCodeAppend("\tfloat afwidth;\n"); + if (dfTexEffect.isUniformScale()) { + // 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("\tafwidth = 0.7071*dx;\n"); + } else { + builder->fsCodeAppend("\tvec2 uv_grad;\n"); + if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) { + // this is to compensate for the Adreno, which likes to drop tiles on division by 0 + builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n"); + builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n"); + builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n"); + builder->fsCodeAppend("\t} else {\n"); + builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n"); + builder->fsCodeAppend("\t}\n"); + } else { + builder->fsCodeAppend("\tuv_grad = normalize(uv);\n"); + } + builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n"); + builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_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("\tafwidth = 0.7071*length(grad);\n"); + } + + builder->fsCodeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n"); + + builder->fsCodeAppendf("\t%s = %s;\n", outputColor, + (GrGLSLExpr4(inputColor) * GrGLSLExpr4("val")).c_str()); + } + + virtual void setData(const GrGLUniformManager& uman, + const GrDrawEffect& drawEffect) SK_OVERRIDE { + SkASSERT(fTextureSizeUni.isValid()); + + GrTexture* texture = drawEffect.effect()->get()->texture(0); + if (texture->width() != fTextureSize.width() || + texture->height() != fTextureSize.height()) { + const GrDistanceFieldLCDTextureEffect& dfTexEffect = + drawEffect.castEffect(); + fTextureSize = SkISize::Make(texture->width(), texture->height()); + float delta = 1.0f/(3.0f*texture->width()); + if (dfTexEffect.useBGR()) { + delta = -delta; + } + uman.set3f(fTextureSizeUni, + SkIntToScalar(fTextureSize.width()), + SkIntToScalar(fTextureSize.height()), + delta); + } + } + + static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { + const GrDistanceFieldLCDTextureEffect& dfTexEffect = + drawEffect.castEffect(); + + int uniformScale = dfTexEffect.isUniformScale() ? 0x01 : 0x00; + int useBGR = dfTexEffect.useBGR() ? 0x10 : 0x00; + return uniformScale | useBGR; + } + +private: + GrGLUniformManager::UniformHandle fTextureSizeUni; + SkISize fTextureSize; + + typedef GrGLVertexEffect INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(GrTexture* texture, + const GrTextureParams& params, + bool uniformScale, + bool useBGR) + : fTextureAccess(texture, params) + , fUniformScale(uniformScale) + , fUseBGR(useBGR) { + this->addTextureAccess(&fTextureAccess); + this->addVertexAttrib(kVec2f_GrSLType); +} + +bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const { + const GrDistanceFieldLCDTextureEffect& cte = CastEffect(other); + return fTextureAccess == cte.fTextureAccess; +} + +void GrDistanceFieldLCDTextureEffect::getConstantColorComponents(GrColor* color, + uint32_t* validFlags) const { + if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) && + GrPixelConfigIsOpaque(this->texture(0)->config())) { + *validFlags = kA_GrColorComponentFlag; + } else { + *validFlags = 0; + } +} + +const GrBackendEffectFactory& GrDistanceFieldLCDTextureEffect::getFactory() const { + return GrTBackendEffectFactory::getInstance(); +} + +/////////////////////////////////////////////////////////////////////////////// + +GR_DEFINE_EFFECT_TEST(GrDistanceFieldLCDTextureEffect); + +GrEffectRef* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random, + GrContext*, + const GrDrawTargetCaps&, + GrTexture* textures[]) { + int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx : + GrEffectUnitTest::kAlphaTextureIdx; + static const SkShader::TileMode kTileModes[] = { + SkShader::kClamp_TileMode, + SkShader::kRepeat_TileMode, + SkShader::kMirror_TileMode, + }; + SkShader::TileMode tileModes[] = { + kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], + kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], + }; + GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : + GrTextureParams::kNone_FilterMode); + + return GrDistanceFieldLCDTextureEffect::Create(textures[texIdx], params, + random->nextBool(), random->nextBool()); }