OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "GrDistanceFieldTextureEffect.h" | 8 #include "GrDistanceFieldTextureEffect.h" |
9 #include "GrFontAtlasSizes.h" | 9 #include "GrFontAtlasSizes.h" |
10 #include "GrInvariantOutput.h" | 10 #include "GrInvariantOutput.h" |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 GrGLGPBuilder* pb = args.fPB; | 44 GrGLGPBuilder* pb = args.fPB; |
45 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); | 45 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
46 SkAssertResult(fsBuilder->enableFeature( | 46 SkAssertResult(fsBuilder->enableFeature( |
47 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); | 47 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); |
48 | 48 |
49 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); | 49 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
50 | 50 |
51 // emit attributes | 51 // emit attributes |
52 vsBuilder->emitAttributes(dfTexEffect); | 52 vsBuilder->emitAttributes(dfTexEffect); |
53 | 53 |
54 GrGLVertToFrag st(kVec2f_GrSLType); | |
55 args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); | |
56 vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoor
ds()->fName); | |
57 | |
58 GrGLVertToFrag uv(kVec2f_GrSLType); | |
59 args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); | |
60 // this is only used with text, so our texture bounds always match the g
lyph atlas | |
61 vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", " | |
62 GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), | |
63 dfTexEffect.inTextureCoords()->fName); | |
64 #ifdef SK_GAMMA_APPLY_TO_A8 | 54 #ifdef SK_GAMMA_APPLY_TO_A8 |
65 // adjust based on gamma | 55 // adjust based on gamma |
66 const char* distanceAdjustUniName = NULL; | 56 const char* distanceAdjustUniName = NULL; |
67 // width, height, 1/(3*width) | 57 // width, height, 1/(3*width) |
68 fDistanceAdjustUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_
Visibility, | 58 fDistanceAdjustUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_
Visibility, |
69 kFloat_GrSLType, kDefault_GrSLPrecision, | 59 kFloat_GrSLType, kDefault_GrSLPrecision, |
70 "DistanceAdjust", &distanceAdjustUniName); | 60 "DistanceAdjust", &distanceAdjustUniName); |
71 #endif | 61 #endif |
72 | 62 |
73 // Setup pass through color | 63 // Setup pass through color |
74 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor
, | 64 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor
, |
75 dfTexEffect.inColor(), &fColorUniform); | 65 dfTexEffect.inColor(), &fColorUniform); |
76 | 66 |
77 // Setup position | 67 // Setup position |
78 this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEf
fect.viewMatrix()); | 68 this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEf
fect.viewMatrix()); |
79 | 69 |
80 // emit transforms | 70 // emit transforms |
| 71 const SkMatrix& localMatrix = dfTexEffect.localMatrix(); |
81 this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosit
ion()->fName, | 72 this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosit
ion()->fName, |
82 dfTexEffect.localMatrix(), args.fTransformsIn, args
.fTransformsOut); | 73 localMatrix, args.fTransformsIn, args.fTransformsOu
t); |
83 | 74 |
| 75 // add varyings |
| 76 GrGLVertToFrag recipScale(kFloat_GrSLType); |
| 77 GrGLVertToFrag st(kVec2f_GrSLType); |
| 78 bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_Distan
ceFieldEffectFlag); |
| 79 const char* viewMatrixName = this->uViewM(); |
| 80 // view matrix name is NULL if identity matrix |
| 81 bool useInverseScale = !localMatrix.isIdentity() && viewMatrixName; |
| 82 if (isSimilarity && useInverseScale) { |
| 83 args.fPB->addVarying("RecipScale", &recipScale, kHigh_GrSLPrecision)
; |
| 84 vsBuilder->codeAppendf("vec2 tx = vec2(%s[0][0], %s[1][0]);", |
| 85 viewMatrixName, viewMatrixName); |
| 86 vsBuilder->codeAppend("float tx2 = dot(tx, tx);"); |
| 87 vsBuilder->codeAppendf("%s = inversesqrt(tx2);", recipScale.vsOut())
; |
| 88 } else { |
| 89 args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); |
| 90 vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTexture
Coords()->fName); |
| 91 } |
| 92 |
| 93 GrGLVertToFrag uv(kVec2f_GrSLType); |
| 94 args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); |
| 95 // this is only used with text, so our texture bounds always match the g
lyph atlas |
| 96 vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", " |
| 97 GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), |
| 98 dfTexEffect.inTextureCoords()->fName); |
| 99 |
84 // Use highp to work around aliasing issues | 100 // Use highp to work around aliasing issues |
85 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, | 101 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, |
86 pb->ctxInfo().stand
ard())); | 102 pb->ctxInfo().stand
ard())); |
87 fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); | 103 fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); |
88 | 104 |
89 fsBuilder->codeAppend("\tfloat texColor = "); | 105 fsBuilder->codeAppend("\tfloat texColor = "); |
90 fsBuilder->appendTextureLookup(args.fSamplers[0], | 106 fsBuilder->appendTextureLookup(args.fSamplers[0], |
91 "uv", | 107 "uv", |
92 kVec2f_GrSLType); | 108 kVec2f_GrSLType); |
93 fsBuilder->codeAppend(".r;\n"); | 109 fsBuilder->codeAppend(".r;\n"); |
94 fsBuilder->codeAppend("\tfloat distance = " | 110 fsBuilder->codeAppend("\tfloat distance = " |
95 SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFie
ldThreshold ");"); | 111 SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFie
ldThreshold ");"); |
96 #ifdef SK_GAMMA_APPLY_TO_A8 | 112 #ifdef SK_GAMMA_APPLY_TO_A8 |
97 // adjust width based on gamma | 113 // adjust width based on gamma |
98 fsBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName); | 114 fsBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName); |
99 #endif | 115 #endif |
100 | 116 |
101 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, | |
102 pb->ctxInfo().stand
ard())); | |
103 fsBuilder->codeAppendf("vec2 st = %s;", st.fsIn()); | |
104 fsBuilder->codeAppend("float afwidth;"); | 117 fsBuilder->codeAppend("float afwidth;"); |
105 if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) { | 118 if (isSimilarity) { |
106 // For uniform scale, we adjust for the effect of the transformation
on the distance | 119 // For uniform scale, we adjust for the effect of the transformation
on the distance |
| 120 // either by using the inverse scale in the view matrix, or (if ther
e is no view matrix) |
107 // by using the length of the gradient of the texture coordinates. W
e use st coordinates | 121 // by using the length of the gradient of the texture coordinates. W
e use st coordinates |
108 // to ensure we're mapping 1:1 from texel space to pixel space. | 122 // with the latter to ensure we're mapping 1:1 from texel space to p
ixel space. |
109 | 123 |
110 // this gives us a smooth step across approximately one fragment | 124 // this gives us a smooth step across approximately one fragment |
111 fsBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dF
dx(st.x));"); | 125 if (useInverseScale) { |
| 126 fsBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor
"*%s);", |
| 127 recipScale.fsIn()); |
| 128 } else { |
| 129 fsBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor
"*dFdx(%s.x));", |
| 130 st.fsIn()); |
| 131 } |
112 } else { | 132 } else { |
113 // For general transforms, to determine the amount of correction we
multiply a unit | 133 // For general transforms, to determine the amount of correction we
multiply a unit |
114 // vector pointing along the SDF gradient direction by the Jacobian
of the st coords | 134 // vector pointing along the SDF gradient direction by the Jacobian
of the st coords |
115 // (which is the inverse transform for this fragment) and take the l
ength of the result. | 135 // (which is the inverse transform for this fragment) and take the l
ength of the result. |
116 fsBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance), dFdy(di
stance));"); | 136 fsBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance), dFdy(di
stance));"); |
117 // the length of the gradient may be 0, so we need to check for this | 137 // the length of the gradient may be 0, so we need to check for this |
118 // this also compensates for the Adreno, which likes to drop tiles o
n division by 0 | 138 // this also compensates for the Adreno, which likes to drop tiles o
n division by 0 |
119 fsBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);"); | 139 fsBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);"); |
120 fsBuilder->codeAppend("if (dg_len2 < 0.0001) {"); | 140 fsBuilder->codeAppend("if (dg_len2 < 0.0001) {"); |
121 fsBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);"); | 141 fsBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);"); |
122 fsBuilder->codeAppend("} else {"); | 142 fsBuilder->codeAppend("} else {"); |
123 fsBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);")
; | 143 fsBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);")
; |
124 fsBuilder->codeAppend("}"); | 144 fsBuilder->codeAppend("}"); |
125 | 145 |
126 fsBuilder->codeAppend("vec2 Jdx = dFdx(st);"); | 146 fsBuilder->codeAppendf("vec2 Jdx = dFdx(%s);", st.fsIn()); |
127 fsBuilder->codeAppend("vec2 Jdy = dFdy(st);"); | 147 fsBuilder->codeAppendf("vec2 Jdy = dFdy(%s);", st.fsIn()); |
128 fsBuilder->codeAppend("vec2 grad = vec2(dist_grad.x*Jdx.x + dist_gra
d.y*Jdy.x,"); | 148 fsBuilder->codeAppend("vec2 grad = vec2(dist_grad.x*Jdx.x + dist_gra
d.y*Jdy.x,"); |
129 fsBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_gra
d.y*Jdy.y);"); | 149 fsBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_gra
d.y*Jdy.y);"); |
130 | 150 |
131 // this gives us a smooth step across approximately one fragment | 151 // this gives us a smooth step across approximately one fragment |
132 fsBuilder->codeAppend("afwidth = " SK_DistanceFieldAAFactor "*length
(grad);"); | 152 fsBuilder->codeAppend("afwidth = " SK_DistanceFieldAAFactor "*length
(grad);"); |
133 } | 153 } |
134 fsBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distanc
e);"); | 154 fsBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distanc
e);"); |
135 | 155 |
136 fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); | 156 fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); |
137 } | 157 } |
(...skipping 25 matching lines...) Expand all Loading... |
163 static inline void GenKey(const GrGeometryProcessor& gp, | 183 static inline void GenKey(const GrGeometryProcessor& gp, |
164 const GrBatchTracker& bt, | 184 const GrBatchTracker& bt, |
165 const GrGLCaps&, | 185 const GrGLCaps&, |
166 GrProcessorKeyBuilder* b) { | 186 GrProcessorKeyBuilder* b) { |
167 const GrDistanceFieldTextureEffect& dfTexEffect = gp.cast<GrDistanceFiel
dTextureEffect>(); | 187 const GrDistanceFieldTextureEffect& dfTexEffect = gp.cast<GrDistanceFiel
dTextureEffect>(); |
168 const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTrack
er>(); | 188 const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTrack
er>(); |
169 uint32_t key = dfTexEffect.getFlags(); | 189 uint32_t key = dfTexEffect.getFlags(); |
170 key |= local.fInputColorType << 16; | 190 key |= local.fInputColorType << 16; |
171 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1
<< 24: 0x0; | 191 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1
<< 24: 0x0; |
172 key |= ComputePosKey(gp.viewMatrix()) << 25; | 192 key |= ComputePosKey(gp.viewMatrix()) << 25; |
| 193 key |= (!gp.viewMatrix().isIdentity() && !gp.localMatrix().isIdentity())
? 0x1 << 27 : 0x0; |
173 b->add32(key); | 194 b->add32(key); |
174 } | 195 } |
175 | 196 |
176 private: | 197 private: |
177 GrColor fColor; | 198 GrColor fColor; |
178 UniformHandle fColorUniform; | 199 UniformHandle fColorUniform; |
179 #ifdef SK_GAMMA_APPLY_TO_A8 | 200 #ifdef SK_GAMMA_APPLY_TO_A8 |
180 float fDistanceAdjust; | 201 float fDistanceAdjust; |
181 UniformHandle fDistanceAdjustUni; | 202 UniformHandle fDistanceAdjustUni; |
182 #endif | 203 #endif |
183 | 204 |
184 typedef GrGLGeometryProcessor INHERITED; | 205 typedef GrGLGeometryProcessor INHERITED; |
185 }; | 206 }; |
186 | 207 |
187 /////////////////////////////////////////////////////////////////////////////// | 208 /////////////////////////////////////////////////////////////////////////////// |
188 | 209 |
189 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrColor color, | 210 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrColor color, |
190 const SkMatrix& viewM
atrix, | 211 const SkMatrix& viewM
atrix, |
| 212 const SkMatrix& local
Matrix, |
191 GrTexture* texture, | 213 GrTexture* texture, |
192 const GrTextureParams
& params, | 214 const GrTextureParams
& params, |
193 #ifdef SK_GAMMA_APPLY_TO_A8 | 215 #ifdef SK_GAMMA_APPLY_TO_A8 |
194 float distanceAdjust, | 216 float distanceAdjust, |
195 #endif | 217 #endif |
196 uint32_t flags, bool
opaqueVertexColors) | 218 uint32_t flags, bool
opaqueVertexColors) |
197 : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors) | 219 : INHERITED(color, viewMatrix, localMatrix, opaqueVertexColors) |
198 , fTextureAccess(texture, params) | 220 , fTextureAccess(texture, params) |
199 #ifdef SK_GAMMA_APPLY_TO_A8 | 221 #ifdef SK_GAMMA_APPLY_TO_A8 |
200 , fDistanceAdjust(distanceAdjust) | 222 , fDistanceAdjust(distanceAdjust) |
201 #endif | 223 #endif |
202 , fFlags(flags & kNonLCD_DistanceFieldEffectMask) | 224 , fFlags(flags & kNonLCD_DistanceFieldEffectMask) |
203 , fInColor(NULL) { | 225 , fInColor(NULL) { |
204 SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); | 226 SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); |
205 this->initClassID<GrDistanceFieldTextureEffect>(); | 227 this->initClassID<GrDistanceFieldTextureEffect>(); |
206 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertex
AttribType)); | 228 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertex
AttribType)); |
207 if (flags & kColorAttr_DistanceFieldEffectFlag) { | 229 if (flags & kColorAttr_DistanceFieldEffectFlag) { |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
274 }; | 296 }; |
275 SkShader::TileMode tileModes[] = { | 297 SkShader::TileMode tileModes[] = { |
276 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], | 298 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
277 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], | 299 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
278 }; | 300 }; |
279 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBil
erp_FilterMode : | 301 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBil
erp_FilterMode : |
280 GrTextureParams::kNon
e_FilterMode); | 302 GrTextureParams::kNon
e_FilterMode); |
281 | 303 |
282 return GrDistanceFieldTextureEffect::Create(GrRandomColor(random), | 304 return GrDistanceFieldTextureEffect::Create(GrRandomColor(random), |
283 GrProcessorUnitTest::TestMatrix(
random), | 305 GrProcessorUnitTest::TestMatrix(
random), |
| 306 GrProcessorUnitTest::TestMatrix(
random), |
284 textures[texIdx], params, | 307 textures[texIdx], params, |
285 #ifdef SK_GAMMA_APPLY_TO_A8 | 308 #ifdef SK_GAMMA_APPLY_TO_A8 |
286 random->nextF(), | 309 random->nextF(), |
287 #endif | 310 #endif |
288 random->nextBool() ? | 311 random->nextBool() ? |
289 kSimilarity_DistanceFieldEff
ectFlag : 0, | 312 kSimilarity_DistanceFieldEff
ectFlag : 0, |
290 random->nextBool()); | 313 random->nextBool()); |
291 } | 314 } |
292 | 315 |
293 /////////////////////////////////////////////////////////////////////////////// | 316 /////////////////////////////////////////////////////////////////////////////// |
(...skipping 263 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
557 const GrDistanceFieldLCDTextureEffect& dfTexEffect = | 580 const GrDistanceFieldLCDTextureEffect& dfTexEffect = |
558 args.fGP.cast<GrDistanceFieldLCDTextureEffect>(); | 581 args.fGP.cast<GrDistanceFieldLCDTextureEffect>(); |
559 const DistanceFieldLCDBatchTracker& local = args.fBT.cast<DistanceFieldL
CDBatchTracker>(); | 582 const DistanceFieldLCDBatchTracker& local = args.fBT.cast<DistanceFieldL
CDBatchTracker>(); |
560 GrGLGPBuilder* pb = args.fPB; | 583 GrGLGPBuilder* pb = args.fPB; |
561 | 584 |
562 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); | 585 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
563 | 586 |
564 // emit attributes | 587 // emit attributes |
565 vsBuilder->emitAttributes(dfTexEffect); | 588 vsBuilder->emitAttributes(dfTexEffect); |
566 | 589 |
567 GrGLVertToFrag st(kVec2f_GrSLType); | |
568 args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); | |
569 vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoor
ds()->fName); | |
570 | |
571 GrGLVertToFrag uv(kVec2f_GrSLType); | |
572 args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); | |
573 // this is only used with text, so our texture bounds always match the g
lyph atlas | |
574 vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", " | |
575 GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), | |
576 dfTexEffect.inTextureCoords()->fName); | |
577 | |
578 // setup pass through color | 590 // setup pass through color |
579 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor
, NULL, | 591 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor
, NULL, |
580 &fColorUniform); | 592 &fColorUniform); |
581 | 593 |
582 // Setup position | 594 // Setup position |
583 this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEf
fect.viewMatrix()); | 595 this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEf
fect.viewMatrix()); |
584 | 596 |
585 // emit transforms | 597 // emit transforms |
| 598 const SkMatrix& localMatrix = dfTexEffect.localMatrix(); |
586 this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosit
ion()->fName, | 599 this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosit
ion()->fName, |
587 dfTexEffect.localMatrix(), args.fTransformsIn, args
.fTransformsOut); | 600 localMatrix, args.fTransformsIn, args.fTransformsOu
t); |
588 | 601 |
| 602 // set up varyings |
| 603 bool isUniformScale = SkToBool(dfTexEffect.getFlags() & kUniformScale_Di
stanceFieldEffectMask); |
| 604 GrGLVertToFrag recipScale(kFloat_GrSLType); |
| 605 GrGLVertToFrag st(kVec2f_GrSLType); |
| 606 const char* viewMatrixName = this->uViewM(); |
| 607 // view matrix name is NULL if identity matrix |
| 608 bool useInverseScale = !localMatrix.isIdentity() && viewMatrixName; |
| 609 if (isUniformScale && useInverseScale) { |
| 610 args.fPB->addVarying("RecipScale", &recipScale, kHigh_GrSLPrecision)
; |
| 611 vsBuilder->codeAppendf("vec2 tx = vec2(%s[0][0], %s[1][0]);", |
| 612 viewMatrixName, viewMatrixName); |
| 613 vsBuilder->codeAppend("float tx2 = dot(tx, tx);"); |
| 614 vsBuilder->codeAppendf("%s = inversesqrt(tx2);", recipScale.vsOut())
; |
| 615 } else { |
| 616 args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); |
| 617 vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTexture
Coords()->fName); |
| 618 } |
| 619 |
| 620 GrGLVertToFrag uv(kVec2f_GrSLType); |
| 621 args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); |
| 622 // this is only used with text, so our texture bounds always match the g
lyph atlas |
| 623 vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_A8_RECIP_WIDTH ", " |
| 624 GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), |
| 625 dfTexEffect.inTextureCoords()->fName); |
| 626 |
| 627 // add frag shader code |
589 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); | 628 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
590 | 629 |
591 SkAssertResult(fsBuilder->enableFeature( | 630 SkAssertResult(fsBuilder->enableFeature( |
592 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); | 631 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); |
593 | 632 |
594 // create LCD offset adjusted by inverse of transform | 633 // create LCD offset adjusted by inverse of transform |
595 // Use highp to work around aliasing issues | 634 // Use highp to work around aliasing issues |
596 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, | 635 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, |
597 pb->ctxInfo().stand
ard())); | 636 pb->ctxInfo().stand
ard())); |
598 fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); | 637 fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); |
599 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, | 638 fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision
, |
600 pb->ctxInfo().stand
ard())); | 639 pb->ctxInfo().stand
ard())); |
601 fsBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn()); | |
602 bool isUniformScale = !!(dfTexEffect.getFlags() & kUniformScale_Distance
FieldEffectMask); | |
603 | |
604 if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) { | 640 if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) { |
605 fsBuilder->codeAppend("float delta = -" GR_FONT_ATLAS_LCD_DELTA ";\n
"); | 641 fsBuilder->codeAppend("float delta = -" GR_FONT_ATLAS_LCD_DELTA ";\n
"); |
606 } else { | 642 } else { |
607 fsBuilder->codeAppend("float delta = " GR_FONT_ATLAS_LCD_DELTA ";\n"
); | 643 fsBuilder->codeAppend("float delta = " GR_FONT_ATLAS_LCD_DELTA ";\n"
); |
608 } | 644 } |
609 if (isUniformScale) { | 645 if (isUniformScale) { |
610 fsBuilder->codeAppend("\tfloat dx = dFdx(st.x);\n"); | 646 if (useInverseScale) { |
611 fsBuilder->codeAppend("\tvec2 offset = vec2(dx*delta, 0.0);\n"); | 647 fsBuilder->codeAppendf("float dx = %s;", recipScale.fsIn()); |
| 648 } else { |
| 649 fsBuilder->codeAppendf("float dx = dFdx(%s.x);", st.fsIn()); |
| 650 } |
| 651 fsBuilder->codeAppend("vec2 offset = vec2(dx*delta, 0.0);"); |
612 } else { | 652 } else { |
613 fsBuilder->codeAppend("\tvec2 Jdx = dFdx(st);\n"); | 653 fsBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn()); |
614 fsBuilder->codeAppend("\tvec2 Jdy = dFdy(st);\n"); | 654 |
615 fsBuilder->codeAppend("\tvec2 offset = delta*Jdx;\n"); | 655 fsBuilder->codeAppend("vec2 Jdx = dFdx(st);"); |
| 656 fsBuilder->codeAppend("vec2 Jdy = dFdy(st);"); |
| 657 fsBuilder->codeAppend("vec2 offset = delta*Jdx;"); |
616 } | 658 } |
617 | 659 |
618 // green is distance to uv center | 660 // green is distance to uv center |
619 fsBuilder->codeAppend("\tvec4 texColor = "); | 661 fsBuilder->codeAppend("\tvec4 texColor = "); |
620 fsBuilder->appendTextureLookup(args.fSamplers[0], "uv", kVec2f_GrSLType)
; | 662 fsBuilder->appendTextureLookup(args.fSamplers[0], "uv", kVec2f_GrSLType)
; |
621 fsBuilder->codeAppend(";\n"); | 663 fsBuilder->codeAppend(";\n"); |
622 fsBuilder->codeAppend("\tvec3 distance;\n"); | 664 fsBuilder->codeAppend("\tvec3 distance;\n"); |
623 fsBuilder->codeAppend("\tdistance.y = texColor.r;\n"); | 665 fsBuilder->codeAppend("\tdistance.y = texColor.r;\n"); |
624 // red is distance to left offset | 666 // red is distance to left offset |
625 fsBuilder->codeAppend("\tvec2 uv_adjusted = uv - offset;\n"); | 667 fsBuilder->codeAppend("\tvec2 uv_adjusted = uv - offset;\n"); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
714 const GrGLCaps&, | 756 const GrGLCaps&, |
715 GrProcessorKeyBuilder* b) { | 757 GrProcessorKeyBuilder* b) { |
716 const GrDistanceFieldLCDTextureEffect& dfTexEffect = | 758 const GrDistanceFieldLCDTextureEffect& dfTexEffect = |
717 gp.cast<GrDistanceFieldLCDTextureEffect>(); | 759 gp.cast<GrDistanceFieldLCDTextureEffect>(); |
718 | 760 |
719 const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatc
hTracker>(); | 761 const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatc
hTracker>(); |
720 uint32_t key = dfTexEffect.getFlags(); | 762 uint32_t key = dfTexEffect.getFlags(); |
721 key |= local.fInputColorType << 16; | 763 key |= local.fInputColorType << 16; |
722 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1
<< 24: 0x0; | 764 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1
<< 24: 0x0; |
723 key |= ComputePosKey(gp.viewMatrix()) << 25; | 765 key |= ComputePosKey(gp.viewMatrix()) << 25; |
| 766 key |= (!gp.viewMatrix().isIdentity() && !gp.localMatrix().isIdentity())
? 0x1 << 27 : 0x0; |
724 b->add32(key); | 767 b->add32(key); |
725 } | 768 } |
726 | 769 |
727 private: | 770 private: |
728 GrColor fColor; | 771 GrColor fColor; |
729 UniformHandle fColorUniform; | 772 UniformHandle fColorUniform; |
730 GrDistanceFieldLCDTextureEffect::DistanceAdjust fDistanceAdjust; | 773 GrDistanceFieldLCDTextureEffect::DistanceAdjust fDistanceAdjust; |
731 UniformHandle fDistanceAdjustUni; | 774 UniformHandle fDistanceAdjustUni; |
732 | 775 |
733 typedef GrGLGeometryProcessor INHERITED; | 776 typedef GrGLGeometryProcessor INHERITED; |
734 }; | 777 }; |
735 | 778 |
736 /////////////////////////////////////////////////////////////////////////////// | 779 /////////////////////////////////////////////////////////////////////////////// |
737 | 780 |
738 GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect( | 781 GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect( |
739 GrColor color, const SkMatrix&
viewMatrix, | 782 GrColor color, const SkMatrix&
viewMatrix, |
| 783 const SkMatrix& localMatrix, |
740 GrTexture* texture, const GrTe
xtureParams& params, | 784 GrTexture* texture, const GrTe
xtureParams& params, |
741 DistanceAdjust distanceAdjust, | 785 DistanceAdjust distanceAdjust, |
742 uint32_t flags) | 786 uint32_t flags) |
743 : INHERITED(color, viewMatrix, SkMatrix::I()) | 787 : INHERITED(color, viewMatrix, localMatrix) |
744 , fTextureAccess(texture, params) | 788 , fTextureAccess(texture, params) |
745 , fDistanceAdjust(distanceAdjust) | 789 , fDistanceAdjust(distanceAdjust) |
746 , fFlags(flags & kLCD_DistanceFieldEffectMask){ | 790 , fFlags(flags & kLCD_DistanceFieldEffectMask){ |
747 SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_Distan
ceFieldEffectFlag)); | 791 SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_Distan
ceFieldEffectFlag)); |
748 this->initClassID<GrDistanceFieldLCDTextureEffect>(); | 792 this->initClassID<GrDistanceFieldLCDTextureEffect>(); |
749 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertex
AttribType)); | 793 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertex
AttribType)); |
750 fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", | 794 fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", |
751 kVec2s_GrVertexAttribT
ype)); | 795 kVec2s_GrVertexAttribT
ype)); |
752 this->addTextureAccess(&fTextureAccess); | 796 this->addTextureAccess(&fTextureAccess); |
753 } | 797 } |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
814 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], | 858 kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
815 }; | 859 }; |
816 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBil
erp_FilterMode : | 860 GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBil
erp_FilterMode : |
817 GrTextureParams::kNone_FilterMode); | 861 GrTextureParams::kNone_FilterMode); |
818 DistanceAdjust wa = { 0.0f, 0.1f, -0.1f }; | 862 DistanceAdjust wa = { 0.0f, 0.1f, -0.1f }; |
819 uint32_t flags = kUseLCD_DistanceFieldEffectFlag; | 863 uint32_t flags = kUseLCD_DistanceFieldEffectFlag; |
820 flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0; | 864 flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0; |
821 flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0; | 865 flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0; |
822 return GrDistanceFieldLCDTextureEffect::Create(GrRandomColor(random), | 866 return GrDistanceFieldLCDTextureEffect::Create(GrRandomColor(random), |
823 GrProcessorUnitTest::TestMatr
ix(random), | 867 GrProcessorUnitTest::TestMatr
ix(random), |
| 868 GrProcessorUnitTest::TestMatr
ix(random), |
824 textures[texIdx], params, | 869 textures[texIdx], params, |
825 wa, | 870 wa, |
826 flags); | 871 flags); |
827 } | 872 } |
OLD | NEW |