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 "gl/builders/GrGLProgramBuilder.h" | 8 #include "gl/builders/GrGLProgramBuilder.h" |
9 #include "GrBezierEffect.h" | 9 #include "GrBezierEffect.h" |
10 | 10 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 const TransformedCoordsArray&, | 50 const TransformedCoordsArray&, |
51 const TextureSamplerArray& samplers) { | 51 const TextureSamplerArray& samplers) { |
52 const char *vsName, *fsName; | 52 const char *vsName, *fsName; |
53 | 53 |
54 builder->addVarying(kVec4f_GrSLType, "ConicCoeffs", | 54 builder->addVarying(kVec4f_GrSLType, "ConicCoeffs", |
55 &vsName, &fsName); | 55 &vsName, &fsName); |
56 | 56 |
57 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 57 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
58 const SkString* attr0Name = | 58 const SkString* attr0Name = |
59 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); | 59 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
60 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); | 60 vsBuilder->codeAppendf("%s = %s;", vsName, attr0Name->c_str()); |
61 | 61 |
62 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 62 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
63 fsBuilder->codeAppend("\t\tfloat edgeAlpha;\n"); | 63 |
| 64 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHig
h_Precision); |
| 65 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); |
| 66 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); |
| 67 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
| 68 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
| 69 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision); |
| 70 GrGLShaderVar gFM("gFM", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision)
; |
| 71 GrGLShaderVar func("func", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
| 72 |
| 73 fsBuilder->declAppend(edgeAlpha); |
| 74 fsBuilder->declAppend(dklmdx); |
| 75 fsBuilder->declAppend(dklmdy); |
| 76 fsBuilder->declAppend(dfdx); |
| 77 fsBuilder->declAppend(dfdy); |
| 78 fsBuilder->declAppend(gF); |
| 79 fsBuilder->declAppend(gFM); |
| 80 fsBuilder->declAppend(func); |
64 | 81 |
65 switch (fEdgeType) { | 82 switch (fEdgeType) { |
66 case kHairlineAA_GrEffectEdgeType: { | 83 case kHairlineAA_GrEffectEdgeType: { |
67 SkAssertResult(fsBuilder->enableFeature( | 84 SkAssertResult(fsBuilder->enableFeature( |
68 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 85 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
69 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 86 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; |
70 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 87 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; |
71 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" | 88 fsBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z
* %s.y;", |
72 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", | 89 dfdx.c_str(), fsName, dklmdx.c_str(), fsName,
dklmdx.c_str(), |
73 fsName, fsName, fsName); | 90 fsName, dklmdx.c_str()); |
74 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" | 91 fsBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z
* %s.y;", |
75 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", | 92 dfdy.c_str(), fsName, dklmdy.c_str(), fsName,
dklmdy.c_str(), |
76 fsName, fsName, fsName); | 93 fsName, dklmdy.c_str()); |
77 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 94 fsBuilder->codeAppendf("%s = vec2(%s, %s);", |
78 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 95 gF.c_str(), dfdx.c_str(), dfdy.c_str()); |
79 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, | 96 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", |
80 fsName, fsName); | 97 gFM.c_str(), gF.c_str(), gF.c_str()); |
81 fsBuilder->codeAppend("\t\tfunc = abs(func);\n"); | 98 fsBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", |
82 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); | 99 func.c_str(), fsName, fsName, fsName, fsName)
; |
83 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | 100 fsBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str()); |
| 101 fsBuilder->codeAppendf("%s = %s / %s;", |
| 102 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; |
| 103 fsBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);", |
| 104 edgeAlpha.c_str(), edgeAlpha.c_str()); |
84 // Add line below for smooth cubic ramp | 105 // Add line below for smooth cubic ramp |
85 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 106 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
| 107 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), |
| 108 // edgeAlpha.c_str()); |
86 break; | 109 break; |
87 } | 110 } |
88 case kFillAA_GrEffectEdgeType: { | 111 case kFillAA_GrEffectEdgeType: { |
89 SkAssertResult(fsBuilder->enableFeature( | 112 SkAssertResult(fsBuilder->enableFeature( |
90 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 113 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
91 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 114 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; |
92 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 115 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; |
93 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" | 116 fsBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z
* %s.y;", |
94 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", | 117 dfdx.c_str(), fsName, dklmdx.c_str(), fsName,
dklmdx.c_str(), |
95 fsName, fsName, fsName); | 118 fsName, dklmdx.c_str()); |
96 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" | 119 fsBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z
* %s.y;", |
97 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", | 120 dfdy.c_str(), fsName, dklmdy.c_str(), fsName,
dklmdy.c_str(), |
98 fsName, fsName, fsName); | 121 fsName, dklmdy.c_str()); |
99 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 122 fsBuilder->codeAppendf("%s = vec2(%s, %s);", |
100 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 123 gF.c_str(), dfdx.c_str(), dfdy.c_str()); |
101 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, | 124 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", |
102 fsName, fsName); | 125 gFM.c_str(), gF.c_str(), gF.c_str()); |
103 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); | 126 fsBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", |
104 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | 127 func.c_str(), fsName, fsName, fsName, fsName)
; |
| 128 fsBuilder->codeAppendf("%s = %s / %s;", |
| 129 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; |
| 130 fsBuilder->codeAppendf("%s = clamp(1.0 - %s, 0.0, 1.0);", |
| 131 edgeAlpha.c_str(), edgeAlpha.c_str()); |
105 // Add line below for smooth cubic ramp | 132 // Add line below for smooth cubic ramp |
106 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 133 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
| 134 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), |
| 135 // edgeAlpha.c_str()); |
107 break; | 136 break; |
108 } | 137 } |
109 case kFillBW_GrEffectEdgeType: { | 138 case kFillBW_GrEffectEdgeType: { |
110 fsBuilder->codeAppendf("\t\tedgeAlpha = %s.x*%s.x - %s.y*%s.z;\n", f
sName, fsName, | 139 fsBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", |
111 fsName, fsName); | 140 edgeAlpha.c_str(), fsName, fsName, fsName, fs
Name); |
112 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | 141 fsBuilder->codeAppendf("%s = float(%s < 0.0);", |
| 142 edgeAlpha.c_str(), edgeAlpha.c_str()); |
113 break; | 143 break; |
114 } | 144 } |
115 default: | 145 default: |
116 SkFAIL("Shouldn't get here"); | 146 SkFAIL("Shouldn't get here"); |
117 } | 147 } |
118 | 148 |
119 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 149 fsBuilder->codeAppendf("%s = %s;", outputColor, |
120 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 150 (GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_st
r())).c_str()); |
121 } | 151 } |
122 | 152 |
123 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 153 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
124 GrEffectKeyBuilder* b) { | 154 GrEffectKeyBuilder* b) { |
125 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); | 155 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); |
126 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 156 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
127 b->add32(key); | 157 b->add32(key); |
128 } | 158 } |
129 | 159 |
130 ////////////////////////////////////////////////////////////////////////////// | 160 ////////////////////////////////////////////////////////////////////////////// |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
201 const char* outputColor, | 231 const char* outputColor, |
202 const char* inputColor, | 232 const char* inputColor, |
203 const TransformedCoordsArray&, | 233 const TransformedCoordsArray&, |
204 const TextureSamplerArray& samplers) { | 234 const TextureSamplerArray& samplers) { |
205 const char *vsName, *fsName; | 235 const char *vsName, *fsName; |
206 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); | 236 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); |
207 | 237 |
208 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 238 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
209 const SkString* attrName = | 239 const SkString* attrName = |
210 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); | 240 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
211 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); | 241 vsBuilder->codeAppendf("%s = %s;", vsName, attrName->c_str()); |
212 | 242 |
213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 243 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
214 fsBuilder->codeAppendf("\t\tfloat edgeAlpha;\n"); | 244 fsBuilder->codeAppendf("float edgeAlpha;"); |
215 | 245 |
216 switch (fEdgeType) { | 246 switch (fEdgeType) { |
217 case kHairlineAA_GrEffectEdgeType: { | 247 case kHairlineAA_GrEffectEdgeType: { |
218 SkAssertResult(fsBuilder->enableFeature( | 248 SkAssertResult(fsBuilder->enableFeature( |
219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 249 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
220 fsBuilder->codeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); | 250 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); |
221 fsBuilder->codeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); | 251 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); |
222 fsBuilder->codeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" | 252 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," |
223 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", | 253 " 2.0 * %s.x * duvdy.x - duvdy.
y);", |
224 fsName, fsName); | 254 fsName, fsName); |
225 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 255 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
226 fsName); | 256 fsBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(
gF, gF));"); |
227 fsBuilder->codeAppend("\t\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / do
t(gF, gF));\n"); | 257 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); |
228 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | |
229 // Add line below for smooth cubic ramp | 258 // Add line below for smooth cubic ramp |
230 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 259 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
231 break; | 260 break; |
232 } | 261 } |
233 case kFillAA_GrEffectEdgeType: { | 262 case kFillAA_GrEffectEdgeType: { |
234 SkAssertResult(fsBuilder->enableFeature( | 263 SkAssertResult(fsBuilder->enableFeature( |
235 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 264 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
236 fsBuilder->codeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); | 265 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); |
237 fsBuilder->codeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); | 266 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); |
238 fsBuilder->codeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" | 267 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," |
239 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", | 268 " 2.0 * %s.x * duvdy.x - duvdy.
y);", |
240 fsName, fsName); | 269 fsName, fsName); |
241 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 270 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
242 fsName); | 271 fsBuilder->codeAppend("edgeAlpha = edgeAlpha / sqrt(dot(gF, gF));"); |
243 fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha / sqrt(dot(gF, gF))
;\n"); | 272 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); |
244 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | |
245 // Add line below for smooth cubic ramp | 273 // Add line below for smooth cubic ramp |
246 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 274 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
247 break; | 275 break; |
248 } | 276 } |
249 case kFillBW_GrEffectEdgeType: { | 277 case kFillBW_GrEffectEdgeType: { |
250 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 278 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
251 fsName); | 279 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); |
252 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | |
253 break; | 280 break; |
254 } | 281 } |
255 default: | 282 default: |
256 SkFAIL("Shouldn't get here"); | 283 SkFAIL("Shouldn't get here"); |
257 } | 284 } |
258 | 285 |
259 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 286 fsBuilder->codeAppendf("%s = %s;", outputColor, |
260 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 287 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
261 } | 288 } |
262 | 289 |
263 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 290 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
264 GrEffectKeyBuilder* b) { | 291 GrEffectKeyBuilder* b) { |
265 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); | 292 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); |
266 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 293 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
267 b->add32(key); | 294 b->add32(key); |
268 } | 295 } |
269 | 296 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
343 const TransformedCoordsArray&, | 370 const TransformedCoordsArray&, |
344 const TextureSamplerArray& samplers) { | 371 const TextureSamplerArray& samplers) { |
345 const char *vsName, *fsName; | 372 const char *vsName, *fsName; |
346 | 373 |
347 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", | 374 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", |
348 &vsName, &fsName); | 375 &vsName, &fsName); |
349 | 376 |
350 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 377 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
351 const SkString* attr0Name = | 378 const SkString* attr0Name = |
352 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); | 379 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
353 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); | 380 vsBuilder->codeAppendf("%s = %s;", vsName, attr0Name->c_str()); |
354 | 381 |
355 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 382 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
356 fsBuilder->codeAppend("\t\tfloat edgeAlpha;\n"); | 383 fsBuilder->codeAppend("float edgeAlpha;"); |
357 | 384 |
358 switch (fEdgeType) { | 385 switch (fEdgeType) { |
359 case kHairlineAA_GrEffectEdgeType: { | 386 case kHairlineAA_GrEffectEdgeType: { |
360 SkAssertResult(fsBuilder->enableFeature( | 387 SkAssertResult(fsBuilder->enableFeature( |
361 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 388 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
362 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 389 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); |
363 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 390 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); |
364 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" | 391 fsBuilder->codeAppendf("float dfdx =" |
365 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", | 392 "3.0*%s.x*%s.x * dklmdx.x - %s.y * dklmdx.z -
%s.z * dklmdx.y;", |
366 fsName, fsName, fsName, fsName); | 393 fsName, fsName, fsName, fsName); |
367 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" | 394 fsBuilder->codeAppendf("float dfdy =" |
368 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", | 395 "3.0*%s.x*%s.x * dklmdy.x - %s.y * dklmdy.z -
%s.z * dklmdy.y;", |
369 fsName, fsName, fsName, fsName); | 396 fsName, fsName, fsName, fsName); |
370 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 397 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); |
371 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 398 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); |
372 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", | 399 fsBuilder->codeAppendf("float func = %s.x * %s.x * %s.x - %s.y * %s.
z;", |
373 fsName, fsName, fsName, fsName, fsName); | 400 fsName, fsName, fsName, fsName, fsName); |
374 fsBuilder->codeAppend("\t\tfunc = abs(func);\n"); | 401 fsBuilder->codeAppend("func = abs(func);"); |
375 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); | 402 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); |
376 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | 403 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); |
377 // Add line below for smooth cubic ramp | 404 // Add line below for smooth cubic ramp |
378 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 405 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
379 break; | 406 break; |
380 } | 407 } |
381 case kFillAA_GrEffectEdgeType: { | 408 case kFillAA_GrEffectEdgeType: { |
382 SkAssertResult(fsBuilder->enableFeature( | 409 SkAssertResult(fsBuilder->enableFeature( |
383 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 410 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
384 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 411 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); |
385 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 412 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); |
386 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" | 413 fsBuilder->codeAppendf("float dfdx =" |
387 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", | 414 "3.0*%s.x*%s.x * dklmdx.x - %s.y * dklmdx.z -
%s.z * dklmdx.y;", |
388 fsName, fsName, fsName, fsName); | 415 fsName, fsName, fsName, fsName); |
389 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" | 416 fsBuilder->codeAppendf("float dfdy =" |
390 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", | 417 "3.0*%s.x*%s.x * dklmdy.x - %s.y * dklmdy.z -
%s.z * dklmdy.y;", |
391 fsName, fsName, fsName, fsName); | 418 fsName, fsName, fsName, fsName); |
392 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 419 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); |
393 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 420 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); |
394 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", | 421 fsBuilder->codeAppendf("float func = %s.x * %s.x * %s.x - %s.y * %s.
z;", |
395 fsName, fsName, fsName, fsName, fsName); | 422 fsName, fsName, fsName, fsName, fsName); |
396 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); | 423 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); |
397 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | 424 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); |
398 // Add line below for smooth cubic ramp | 425 // Add line below for smooth cubic ramp |
399 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 426 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
400 break; | 427 break; |
401 } | 428 } |
402 case kFillBW_GrEffectEdgeType: { | 429 case kFillBW_GrEffectEdgeType: { |
403 fsBuilder->codeAppendf("\t\tedgeAlpha = %s.x*%s.x*%s.x - %s.y*%s.z;\
n", | 430 fsBuilder->codeAppendf("edgeAlpha = %s.x * %s.x * %s.x - %s.y * %s.z
;", |
404 fsName, fsName, fsName, fsName, fsName); | 431 fsName, fsName, fsName, fsName, fsName); |
405 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | 432 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); |
406 break; | 433 break; |
407 } | 434 } |
408 default: | 435 default: |
409 SkFAIL("Shouldn't get here"); | 436 SkFAIL("Shouldn't get here"); |
410 } | 437 } |
411 | 438 |
412 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 439 fsBuilder->codeAppendf("%s = %s;", outputColor, |
413 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 440 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
414 } | 441 } |
415 | 442 |
416 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 443 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
417 GrEffectKeyBuilder* b) { | 444 GrEffectKeyBuilder* b) { |
418 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); | 445 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); |
419 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 446 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
420 b->add32(key); | 447 b->add32(key); |
421 } | 448 } |
422 | 449 |
(...skipping 24 matching lines...) Expand all Loading... |
447 const GrDrawTargetCaps& caps, | 474 const GrDrawTargetCaps& caps, |
448 GrTexture*[]) { | 475 GrTexture*[]) { |
449 GrEffect* effect; | 476 GrEffect* effect; |
450 do { | 477 do { |
451 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 478 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
452 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 479 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); |
453 effect = GrCubicEffect::Create(edgeType, caps); | 480 effect = GrCubicEffect::Create(edgeType, caps); |
454 } while (NULL == effect); | 481 } while (NULL == effect); |
455 return effect; | 482 return effect; |
456 } | 483 } |
OLD | NEW |