blob: 7ef1cbb2ba3c64719a045d27d0ae145897488953 [file] [log] [blame]
jvanverth@google.comd830d132013-11-11 20:54:09 +00001/*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "GrDistanceFieldTextureEffect.h"
9#include "gl/GrGLEffect.h"
bsalomon848faf02014-07-11 10:01:02 -070010#include "gl/GrGLShaderBuilder.h"
jvanverth@google.comd830d132013-11-11 20:54:09 +000011#include "gl/GrGLSL.h"
12#include "gl/GrGLTexture.h"
13#include "gl/GrGLVertexEffect.h"
14#include "GrTBackendEffectFactory.h"
15#include "GrTexture.h"
16
commit-bot@chromium.org762cd802014-04-14 22:05:07 +000017#include "SkDistanceFieldGen.h"
jvanverth@google.comd830d132013-11-11 20:54:09 +000018
jvanverth2d2a68c2014-06-10 06:42:56 -070019// To get optical sizes people don't complain about when we blit correctly,
20// we need to slightly bold each glyph. On the Mac, we need a larger bold value.
21#if defined(SK_BUILD_FOR_MAC)
22#define SK_DistanceFieldLCDFactor "0.33"
23#define SK_DistanceFieldNonLCDFactor "0.25"
24#else
25#define SK_DistanceFieldLCDFactor "0.05"
26#define SK_DistanceFieldNonLCDFactor "0.05"
27#endif
28
29// Assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2
30#define SK_DistanceFieldAAFactor "0.7071"
31
jvanverth@google.comd830d132013-11-11 20:54:09 +000032class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect {
33public:
skia.committer@gmail.coma3b53272014-02-15 03:02:15 +000034 GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000035 const GrDrawEffect& drawEffect)
36 : INHERITED (factory)
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000037 , fTextureSize(SkISize::Make(-1,-1)) {}
jvanverth@google.comd830d132013-11-11 20:54:09 +000038
39 virtual void emitCode(GrGLFullShaderBuilder* builder,
40 const GrDrawEffect& drawEffect,
bsalomon63e99f72014-07-21 08:03:14 -070041 const GrEffectKey& key,
jvanverth@google.comd830d132013-11-11 20:54:09 +000042 const char* outputColor,
43 const char* inputColor,
44 const TransformedCoordsArray&,
45 const TextureSamplerArray& samplers) SK_OVERRIDE {
46 SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
47
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000048 SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000049 const GrDistanceFieldTextureEffect& dfTexEffect =
50 drawEffect.castEffect<GrDistanceFieldTextureEffect>();
jvanverth@google.comd830d132013-11-11 20:54:09 +000051
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000052 SkString fsCoordName;
53 const char* vsCoordName;
54 const char* fsCoordNamePtr;
55 builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
56 fsCoordName = fsCoordNamePtr;
57
58 const char* attrName0 =
jvanverth@google.comd830d132013-11-11 20:54:09 +000059 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000060 builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
61
62 const char* textureSizeUniName = NULL;
63 fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
64 kVec2f_GrSLType, "TextureSize",
65 &textureSizeUniName);
jvanverth@google.comd830d132013-11-11 20:54:09 +000066
67 builder->fsCodeAppend("\tvec4 texColor = ");
68 builder->fsAppendTextureLookup(samplers[0],
69 fsCoordName.c_str(),
70 kVec2f_GrSLType);
71 builder->fsCodeAppend(";\n");
skia.committer@gmail.coma1ed7ae2014-04-15 03:04:18 +000072 builder->fsCodeAppend("\tfloat distance = "
jvanverth2d2a68c2014-06-10 06:42:56 -070073 SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ")"
74 "+ " SK_DistanceFieldNonLCDFactor ";\n");
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000075
76 // we adjust for the effect of the transformation on the distance by using
77 // the length of the gradient of the texture coordinates. We use st coordinates
78 // to ensure we're mapping 1:1 from texel space to pixel space.
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000079 builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
80 builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
81 builder->fsCodeAppend("\tfloat afwidth;\n");
jvanverth78f07182014-07-30 06:17:59 -070082 if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) {
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000083 // this gives us a smooth step across approximately one fragment
jvanverth2d2a68c2014-06-10 06:42:56 -070084 builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dFdx(st.x);\n");
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000085 } else {
86 builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
87 builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +000088
commit-bot@chromium.org4362a382014-03-26 19:49:03 +000089 builder->fsCodeAppend("\tvec2 uv_grad;\n");
90 if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
91 // this is to compensate for the Adreno, which likes to drop tiles on division by 0
92 builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
93 builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
94 builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
95 builder->fsCodeAppend("\t} else {\n");
96 builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
97 builder->fsCodeAppend("\t}\n");
98 } else {
99 builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
100 }
101 builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
102 builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
103
104 // this gives us a smooth step across approximately one fragment
jvanverth2d2a68c2014-06-10 06:42:56 -0700105 builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
commit-bot@chromium.org4362a382014-03-26 19:49:03 +0000106 }
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +0000107 builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
jvanverth@google.comd830d132013-11-11 20:54:09 +0000108
jvanverth2d2a68c2014-06-10 06:42:56 -0700109#ifdef SK_GAMMA_APPLY_TO_A8
110 // adjust based on gamma
111 const char* luminanceUniName = NULL;
112 // width, height, 1/(3*width)
113 fLuminanceUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
114 kFloat_GrSLType, "Luminance",
115 &luminanceUniName);
116
117 builder->fsCodeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName);
118 builder->fsCodeAppend("\tvec4 gammaColor = ");
119 builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
120 builder->fsCodeAppend(";\n");
121 builder->fsCodeAppend("\tval = gammaColor.r;\n");
122#endif
123
jvanverth@google.comd830d132013-11-11 20:54:09 +0000124 builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
125 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
126 }
127
kkinnunen7510b222014-07-30 00:04:16 -0700128 virtual void setData(const GrGLProgramDataManager& pdman,
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +0000129 const GrDrawEffect& drawEffect) SK_OVERRIDE {
130 SkASSERT(fTextureSizeUni.isValid());
commit-bot@chromium.org4362a382014-03-26 19:49:03 +0000131
bsalomonf99f8842014-07-07 11:54:23 -0700132 GrTexture* texture = drawEffect.effect()->texture(0);
commit-bot@chromium.org4362a382014-03-26 19:49:03 +0000133 if (texture->width() != fTextureSize.width() ||
134 texture->height() != fTextureSize.height()) {
135 fTextureSize = SkISize::Make(texture->width(), texture->height());
kkinnunen7510b222014-07-30 00:04:16 -0700136 pdman.set2f(fTextureSizeUni,
137 SkIntToScalar(fTextureSize.width()),
138 SkIntToScalar(fTextureSize.height()));
commit-bot@chromium.org66beaf02014-03-26 18:21:55 +0000139 }
jvanverth2d2a68c2014-06-10 06:42:56 -0700140#ifdef SK_GAMMA_APPLY_TO_A8
141 const GrDistanceFieldTextureEffect& dfTexEffect =
142 drawEffect.castEffect<GrDistanceFieldTextureEffect>();
143 float luminance = dfTexEffect.getLuminance();
144 if (luminance != fLuminance) {
kkinnunen7510b222014-07-30 00:04:16 -0700145 pdman.set1f(fLuminanceUni, luminance);
jvanverth2d2a68c2014-06-10 06:42:56 -0700146 fLuminance = luminance;
147 }
148#endif
commit-bot@chromium.org8fe2ee12014-03-26 18:03:05 +0000149 }
150
bsalomon63e99f72014-07-21 08:03:14 -0700151 static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
152 GrEffectKeyBuilder* b) {
commit-bot@chromium.org4362a382014-03-26 19:49:03 +0000153 const GrDistanceFieldTextureEffect& dfTexEffect =
154 drawEffect.castEffect<GrDistanceFieldTextureEffect>();
155
jvanverth78f07182014-07-30 06:17:59 -0700156 b->add32(dfTexEffect.getFlags());
commit-bot@chromium.org4362a382014-03-26 19:49:03 +0000157 }
158
jvanverth@google.comd830d132013-11-11 20:54:09 +0000159private:
kkinnunen7510b222014-07-30 00:04:16 -0700160 GrGLProgramDataManager::UniformHandle fTextureSizeUni;
161 SkISize fTextureSize;
162 GrGLProgramDataManager::UniformHandle fLuminanceUni;
163 float fLuminance;
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +0000164
jvanverth@google.comd830d132013-11-11 20:54:09 +0000165 typedef GrGLVertexEffect INHERITED;
166};
167
168///////////////////////////////////////////////////////////////////////////////
169
170GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +0000171 const GrTextureParams& params,
jvanverth2d2a68c2014-06-10 06:42:56 -0700172#ifdef SK_GAMMA_APPLY_TO_A8
173 GrTexture* gamma,
174 const GrTextureParams& gammaParams,
175 float luminance,
176#endif
jvanverth78f07182014-07-30 06:17:59 -0700177 uint32_t flags)
commit-bot@chromium.org6c89c342014-02-14 21:48:29 +0000178 : fTextureAccess(texture, params)
jvanverth2d2a68c2014-06-10 06:42:56 -0700179#ifdef SK_GAMMA_APPLY_TO_A8
180 , fGammaTextureAccess(gamma, gammaParams)
181 , fLuminance(luminance)
182#endif
jvanverth78f07182014-07-30 06:17:59 -0700183 , fFlags(flags & kNonLCD_DistanceFieldEffectMask) {
184 SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
jvanverth@google.comd830d132013-11-11 20:54:09 +0000185 this->addTextureAccess(&fTextureAccess);
jvanverth2d2a68c2014-06-10 06:42:56 -0700186#ifdef SK_GAMMA_APPLY_TO_A8
187 this->addTextureAccess(&fGammaTextureAccess);
188#endif
jvanverth@google.comd830d132013-11-11 20:54:09 +0000189 this->addVertexAttrib(kVec2f_GrSLType);
190}
191
192bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
193 const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
jvanverth78f07182014-07-30 06:17:59 -0700194 return fTextureAccess == cte.fTextureAccess &&
195#ifdef SK_GAMMA_APPLY_TO_A8
196 fGammaTextureAccess == cte.fGammaTextureAccess &&
197 fLuminance == cte.fLuminance &&
198#endif
199 fFlags == cte.fFlags;
jvanverth@google.comd830d132013-11-11 20:54:09 +0000200}
201
202void GrDistanceFieldTextureEffect::getConstantColorComponents(GrColor* color,
203 uint32_t* validFlags) const {
204 if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
205 GrPixelConfigIsOpaque(this->texture(0)->config())) {
206 *validFlags = kA_GrColorComponentFlag;
207 } else {
208 *validFlags = 0;
209 }
210}
211
212const GrBackendEffectFactory& GrDistanceFieldTextureEffect::getFactory() const {
213 return GrTBackendEffectFactory<GrDistanceFieldTextureEffect>::getInstance();
214}
215
216///////////////////////////////////////////////////////////////////////////////
217
218GR_DEFINE_EFFECT_TEST(GrDistanceFieldTextureEffect);
219
bsalomon83d081a2014-07-08 09:56:10 -0700220GrEffect* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
221 GrContext*,
222 const GrDrawTargetCaps&,
223 GrTexture* textures[]) {
jvanverth@google.comd830d132013-11-11 20:54:09 +0000224 int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
225 GrEffectUnitTest::kAlphaTextureIdx;
jvanverth2d2a68c2014-06-10 06:42:56 -0700226#ifdef SK_GAMMA_APPLY_TO_A8
227 int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
228 GrEffectUnitTest::kAlphaTextureIdx;
229#endif
jvanverth@google.comd830d132013-11-11 20:54:09 +0000230 static const SkShader::TileMode kTileModes[] = {
231 SkShader::kClamp_TileMode,
232 SkShader::kRepeat_TileMode,
233 SkShader::kMirror_TileMode,
234 };
235 SkShader::TileMode tileModes[] = {
236 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
237 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
238 };
239 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
240 GrTextureParams::kNone_FilterMode);
jvanverth2d2a68c2014-06-10 06:42:56 -0700241#ifdef SK_GAMMA_APPLY_TO_A8
242 GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
243 GrTextureParams::kNone_FilterMode);
244#endif
jvanverth@google.comd830d132013-11-11 20:54:09 +0000245
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000246 return GrDistanceFieldTextureEffect::Create(textures[texIdx], params,
jvanverth2d2a68c2014-06-10 06:42:56 -0700247#ifdef SK_GAMMA_APPLY_TO_A8
248 textures[texIdx2], params2,
249 random->nextF(),
250#endif
jvanverth78f07182014-07-30 06:17:59 -0700251 random->nextBool() ?
252 kSimilarity_DistanceFieldEffectFlag : 0);
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000253}
254
255///////////////////////////////////////////////////////////////////////////////
256
257class GrGLDistanceFieldLCDTextureEffect : public GrGLVertexEffect {
258public:
259 GrGLDistanceFieldLCDTextureEffect(const GrBackendEffectFactory& factory,
260 const GrDrawEffect& drawEffect)
261 : INHERITED (factory)
262 , fTextureSize(SkISize::Make(-1,-1)) {}
263
264 virtual void emitCode(GrGLFullShaderBuilder* builder,
265 const GrDrawEffect& drawEffect,
bsalomon63e99f72014-07-21 08:03:14 -0700266 const GrEffectKey& key,
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000267 const char* outputColor,
268 const char* inputColor,
269 const TransformedCoordsArray&,
270 const TextureSamplerArray& samplers) SK_OVERRIDE {
271 SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>().numVertexAttribs());
272
273 SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
274 const GrDistanceFieldLCDTextureEffect& dfTexEffect =
275 drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
276
277 SkString fsCoordName;
278 const char* vsCoordName;
279 const char* fsCoordNamePtr;
280 builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
281 fsCoordName = fsCoordNamePtr;
282
283 const char* attrName0 =
jvanverth2d2a68c2014-06-10 06:42:56 -0700284 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000285 builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
286
287 const char* textureSizeUniName = NULL;
288 // width, height, 1/(3*width)
289 fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
290 kVec3f_GrSLType, "TextureSize",
291 &textureSizeUniName);
292
293 // create LCD offset adjusted by inverse of transform
294 builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
295 builder->fsCodeAppendf("\tvec2 st = uv*%s.xy;\n", textureSizeUniName);
jvanverth78f07182014-07-30 06:17:59 -0700296 bool isUniformScale = !!(dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask);
297 if (isUniformScale) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000298 builder->fsCodeAppend("\tfloat dx = dFdx(st.x);\n");
299 builder->fsCodeAppendf("\tvec2 offset = vec2(dx*%s.z, 0.0);\n", textureSizeUniName);
300 } else {
301 builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
302 builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
303 builder->fsCodeAppendf("\tvec2 offset = %s.z*Jdx;\n", textureSizeUniName);
304 }
305
306 // green is distance to uv center
307 builder->fsCodeAppend("\tvec4 texColor = ");
308 builder->fsAppendTextureLookup(samplers[0], "uv", kVec2f_GrSLType);
309 builder->fsCodeAppend(";\n");
310 builder->fsCodeAppend("\tvec3 distance;\n");
jvanverth2d2a68c2014-06-10 06:42:56 -0700311 builder->fsCodeAppend("\tdistance.y = texColor.r;\n");
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000312 // red is distance to left offset
313 builder->fsCodeAppend("\tvec2 uv_adjusted = uv - offset;\n");
314 builder->fsCodeAppend("\ttexColor = ");
315 builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
316 builder->fsCodeAppend(";\n");
jvanverth2d2a68c2014-06-10 06:42:56 -0700317 builder->fsCodeAppend("\tdistance.x = texColor.r;\n");
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000318 // blue is distance to right offset
319 builder->fsCodeAppend("\tuv_adjusted = uv + offset;\n");
320 builder->fsCodeAppend("\ttexColor = ");
321 builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
322 builder->fsCodeAppend(";\n");
jvanverth2d2a68c2014-06-10 06:42:56 -0700323 builder->fsCodeAppend("\tdistance.z = texColor.r;\n");
324
325 builder->fsCodeAppend("\tdistance = "
326 "vec3(" SK_DistanceFieldMultiplier ")*(distance - vec3(" SK_DistanceFieldThreshold"))"
327 "+ vec3(" SK_DistanceFieldLCDFactor ");\n");
328
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000329 // we adjust for the effect of the transformation on the distance by using
330 // the length of the gradient of the texture coordinates. We use st coordinates
331 // to ensure we're mapping 1:1 from texel space to pixel space.
332
333 // To be strictly correct, we should compute the anti-aliasing factor separately
334 // for each color component. However, this is only important when using perspective
335 // transformations, and even then using a single factor seems like a reasonable
336 // trade-off between quality and speed.
337 builder->fsCodeAppend("\tfloat afwidth;\n");
jvanverth78f07182014-07-30 06:17:59 -0700338 if (isUniformScale) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000339 // this gives us a smooth step across approximately one fragment
jvanverth2d2a68c2014-06-10 06:42:56 -0700340 builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dx;\n");
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000341 } else {
342 builder->fsCodeAppend("\tvec2 uv_grad;\n");
343 if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
344 // this is to compensate for the Adreno, which likes to drop tiles on division by 0
345 builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
346 builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
347 builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
348 builder->fsCodeAppend("\t} else {\n");
349 builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
350 builder->fsCodeAppend("\t}\n");
351 } else {
352 builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
353 }
354 builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
355 builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
356
357 // this gives us a smooth step across approximately one fragment
jvanverth2d2a68c2014-06-10 06:42:56 -0700358 builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000359 }
360
361 builder->fsCodeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n");
362
jvanverth2d2a68c2014-06-10 06:42:56 -0700363 // adjust based on gamma
364 const char* textColorUniName = NULL;
365 // width, height, 1/(3*width)
366 fTextColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
367 kVec3f_GrSLType, "TextColor",
368 &textColorUniName);
369
370 builder->fsCodeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName);
371 builder->fsCodeAppend("\tvec4 gammaColor = ");
372 builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
373 builder->fsCodeAppend(";\n");
374 builder->fsCodeAppend("\tval.x = gammaColor.r;\n");
375
376 builder->fsCodeAppendf("\tuv = vec2(val.y, %s.y);\n", textColorUniName);
377 builder->fsCodeAppend("\tgammaColor = ");
378 builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
379 builder->fsCodeAppend(";\n");
380 builder->fsCodeAppend("\tval.y = gammaColor.r;\n");
381
382 builder->fsCodeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName);
383 builder->fsCodeAppend("\tgammaColor = ");
384 builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
385 builder->fsCodeAppend(";\n");
386 builder->fsCodeAppend("\tval.z = gammaColor.r;\n");
387
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000388 builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
389 (GrGLSLExpr4(inputColor) * GrGLSLExpr4("val")).c_str());
390 }
391
kkinnunen7510b222014-07-30 00:04:16 -0700392 virtual void setData(const GrGLProgramDataManager& pdman,
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000393 const GrDrawEffect& drawEffect) SK_OVERRIDE {
394 SkASSERT(fTextureSizeUni.isValid());
jvanverth2d2a68c2014-06-10 06:42:56 -0700395 SkASSERT(fTextColorUni.isValid());
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000396
jvanverth2d2a68c2014-06-10 06:42:56 -0700397 const GrDistanceFieldLCDTextureEffect& dfTexEffect =
398 drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
bsalomonf99f8842014-07-07 11:54:23 -0700399 GrTexture* texture = drawEffect.effect()->texture(0);
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000400 if (texture->width() != fTextureSize.width() ||
401 texture->height() != fTextureSize.height()) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000402 fTextureSize = SkISize::Make(texture->width(), texture->height());
403 float delta = 1.0f/(3.0f*texture->width());
jvanverth78f07182014-07-30 06:17:59 -0700404 if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000405 delta = -delta;
406 }
kkinnunen7510b222014-07-30 00:04:16 -0700407 pdman.set3f(fTextureSizeUni,
408 SkIntToScalar(fTextureSize.width()),
409 SkIntToScalar(fTextureSize.height()),
410 delta);
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000411 }
jvanverth2d2a68c2014-06-10 06:42:56 -0700412
413 GrColor textColor = dfTexEffect.getTextColor();
414 if (textColor != fTextColor) {
415 static const float ONE_OVER_255 = 1.f / 255.f;
kkinnunen7510b222014-07-30 00:04:16 -0700416 pdman.set3f(fTextColorUni,
417 GrColorUnpackR(textColor) * ONE_OVER_255,
418 GrColorUnpackG(textColor) * ONE_OVER_255,
419 GrColorUnpackB(textColor) * ONE_OVER_255);
jvanverth2d2a68c2014-06-10 06:42:56 -0700420 fTextColor = textColor;
421 }
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000422 }
423
bsalomon63e99f72014-07-21 08:03:14 -0700424 static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
425 GrEffectKeyBuilder* b) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000426 const GrDistanceFieldLCDTextureEffect& dfTexEffect =
427 drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
428
jvanverth78f07182014-07-30 06:17:59 -0700429 b->add32(dfTexEffect.getFlags());
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000430 }
431
432private:
kkinnunen7510b222014-07-30 00:04:16 -0700433 GrGLProgramDataManager::UniformHandle fTextureSizeUni;
434 SkISize fTextureSize;
435 GrGLProgramDataManager::UniformHandle fTextColorUni;
436 SkColor fTextColor;
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000437
438 typedef GrGLVertexEffect INHERITED;
439};
440
441///////////////////////////////////////////////////////////////////////////////
442
jvanverth2d2a68c2014-06-10 06:42:56 -0700443GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect(
444 GrTexture* texture, const GrTextureParams& params,
445 GrTexture* gamma, const GrTextureParams& gParams,
446 SkColor textColor,
jvanverth78f07182014-07-30 06:17:59 -0700447 uint32_t flags)
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000448 : fTextureAccess(texture, params)
jvanverth2d2a68c2014-06-10 06:42:56 -0700449 , fGammaTextureAccess(gamma, gParams)
450 , fTextColor(textColor)
jvanverth78f07182014-07-30 06:17:59 -0700451 , fFlags(flags & kLCD_DistanceFieldEffectMask) {
452 SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
453
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000454 this->addTextureAccess(&fTextureAccess);
jvanverth2d2a68c2014-06-10 06:42:56 -0700455 this->addTextureAccess(&fGammaTextureAccess);
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000456 this->addVertexAttrib(kVec2f_GrSLType);
457}
458
459bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const {
jvanverth2d2a68c2014-06-10 06:42:56 -0700460 const GrDistanceFieldLCDTextureEffect& cte =
461 CastEffect<GrDistanceFieldLCDTextureEffect>(other);
jvanverth78f07182014-07-30 06:17:59 -0700462 return (fTextureAccess == cte.fTextureAccess &&
463 fGammaTextureAccess == cte.fGammaTextureAccess &&
464 fTextColor == cte.fTextColor &&
465 fFlags == cte.fFlags);
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000466}
467
468void GrDistanceFieldLCDTextureEffect::getConstantColorComponents(GrColor* color,
469 uint32_t* validFlags) const {
470 if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
471 GrPixelConfigIsOpaque(this->texture(0)->config())) {
472 *validFlags = kA_GrColorComponentFlag;
473 } else {
474 *validFlags = 0;
475 }
476}
477
478const GrBackendEffectFactory& GrDistanceFieldLCDTextureEffect::getFactory() const {
479 return GrTBackendEffectFactory<GrDistanceFieldLCDTextureEffect>::getInstance();
480}
481
482///////////////////////////////////////////////////////////////////////////////
483
484GR_DEFINE_EFFECT_TEST(GrDistanceFieldLCDTextureEffect);
485
bsalomon83d081a2014-07-08 09:56:10 -0700486GrEffect* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random,
487 GrContext*,
488 const GrDrawTargetCaps&,
489 GrTexture* textures[]) {
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000490 int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
jvanverth2d2a68c2014-06-10 06:42:56 -0700491 GrEffectUnitTest::kAlphaTextureIdx;
492 int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
493 GrEffectUnitTest::kAlphaTextureIdx;
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000494 static const SkShader::TileMode kTileModes[] = {
495 SkShader::kClamp_TileMode,
496 SkShader::kRepeat_TileMode,
497 SkShader::kMirror_TileMode,
498 };
499 SkShader::TileMode tileModes[] = {
500 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
501 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
502 };
503 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
504 GrTextureParams::kNone_FilterMode);
jvanverth2d2a68c2014-06-10 06:42:56 -0700505 GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
506 GrTextureParams::kNone_FilterMode);
507 GrColor textColor = GrColorPackRGBA(random->nextULessThan(256),
508 random->nextULessThan(256),
509 random->nextULessThan(256),
510 random->nextULessThan(256));
jvanverth78f07182014-07-30 06:17:59 -0700511 uint32_t flags = kUseLCD_DistanceFieldEffectFlag;
512 flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0;
513 flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0;
commit-bot@chromium.org609ced42014-04-03 18:25:48 +0000514 return GrDistanceFieldLCDTextureEffect::Create(textures[texIdx], params,
jvanverth2d2a68c2014-06-10 06:42:56 -0700515 textures[texIdx2], params2,
516 textColor,
jvanverth78f07182014-07-30 06:17:59 -0700517 flags);
jvanverth@google.comd830d132013-11-11 20:54:09 +0000518}