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 "GrBezierEffect.h" | 9 #include "GrBezierEffect.h" |
9 | 10 |
10 #include "gl/GrGLEffect.h" | 11 #include "gl/GrGLEffect.h" |
11 #include "gl/GrGLShaderBuilder.h" | |
12 #include "gl/GrGLSL.h" | 12 #include "gl/GrGLSL.h" |
13 #include "gl/GrGLVertexEffect.h" | 13 #include "gl/GrGLVertexEffect.h" |
14 #include "GrTBackendEffectFactory.h" | 14 #include "GrTBackendEffectFactory.h" |
15 | 15 |
16 class GrGLConicEffect : public GrGLVertexEffect { | 16 class GrGLConicEffect : public GrGLVertexEffect { |
17 public: | 17 public: |
18 GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | 18 GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
19 | 19 |
20 virtual void emitCode(GrGLFullShaderBuilder* builder, | 20 virtual void emitCode(GrGLFullProgramBuilder* builder, |
21 const GrDrawEffect& drawEffect, | 21 const GrDrawEffect& drawEffect, |
22 const GrEffectKey& key, | 22 const GrEffectKey& key, |
23 const char* outputColor, | 23 const char* outputColor, |
24 const char* inputColor, | 24 const char* inputColor, |
25 const TransformedCoordsArray&, | 25 const TransformedCoordsArray&, |
26 const TextureSamplerArray&) SK_OVERRIDE; | 26 const TextureSamplerArray&) SK_OVERRIDE; |
27 | 27 |
28 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); | 28 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
29 | 29 |
30 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} | 30 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} |
31 | 31 |
32 private: | 32 private: |
33 GrEffectEdgeType fEdgeType; | 33 GrEffectEdgeType fEdgeType; |
34 | 34 |
35 typedef GrGLVertexEffect INHERITED; | 35 typedef GrGLVertexEffect INHERITED; |
36 }; | 36 }; |
37 | 37 |
38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory, | 38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory, |
39 const GrDrawEffect& drawEffect) | 39 const GrDrawEffect& drawEffect) |
40 : INHERITED (factory) { | 40 : INHERITED (factory) { |
41 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); | 41 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); |
42 fEdgeType = ce.getEdgeType(); | 42 fEdgeType = ce.getEdgeType(); |
43 } | 43 } |
44 | 44 |
45 void GrGLConicEffect::emitCode(GrGLFullShaderBuilder* builder, | 45 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder, |
46 const GrDrawEffect& drawEffect, | 46 const GrDrawEffect& drawEffect, |
47 const GrEffectKey& key, | 47 const GrEffectKey& key, |
48 const char* outputColor, | 48 const char* outputColor, |
49 const char* inputColor, | 49 const char* inputColor, |
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 |
| 57 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
56 const SkString* attr0Name = | 58 const SkString* attr0Name = |
57 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); | 59 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
58 builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); | 60 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); |
59 | 61 |
60 builder->fsCodeAppend("\t\tfloat edgeAlpha;\n"); | 62 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 63 fsBuilder->codeAppend("\t\tfloat edgeAlpha;\n"); |
61 | 64 |
62 switch (fEdgeType) { | 65 switch (fEdgeType) { |
63 case kHairlineAA_GrEffectEdgeType: { | 66 case kHairlineAA_GrEffectEdgeType: { |
64 SkAssertResult(builder->enableFeature( | 67 SkAssertResult(fsBuilder->enableFeature( |
65 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 68 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
66 builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 69 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); |
67 builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 70 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); |
68 builder->fsCodeAppendf("\t\tfloat dfdx =\n" | 71 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" |
69 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", | 72 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", |
70 fsName, fsName, fsName); | 73 fsName, fsName, fsName); |
71 builder->fsCodeAppendf("\t\tfloat dfdy =\n" | 74 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" |
72 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", | 75 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", |
73 fsName, fsName, fsName); | 76 fsName, fsName, fsName); |
74 builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 77 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); |
75 builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 78 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); |
76 builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, | 79 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, |
77 fsName, fsName); | 80 fsName, fsName); |
78 builder->fsCodeAppend("\t\tfunc = abs(func);\n"); | 81 fsBuilder->codeAppend("\t\tfunc = abs(func);\n"); |
79 builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n"); | 82 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); |
80 builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | 83 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); |
81 // Add line below for smooth cubic ramp | 84 // Add line below for smooth cubic ramp |
82 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 85 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
83 break; | 86 break; |
84 } | 87 } |
85 case kFillAA_GrEffectEdgeType: { | 88 case kFillAA_GrEffectEdgeType: { |
86 SkAssertResult(builder->enableFeature( | 89 SkAssertResult(fsBuilder->enableFeature( |
87 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 90 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
88 builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 91 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); |
89 builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 92 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); |
90 builder->fsCodeAppendf("\t\tfloat dfdx =\n" | 93 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" |
91 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", | 94 "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s
.z*dklmdx.y;\n", |
92 fsName, fsName, fsName); | 95 fsName, fsName, fsName); |
93 builder->fsCodeAppendf("\t\tfloat dfdy =\n" | 96 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" |
94 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", | 97 "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s
.z*dklmdy.y;\n", |
95 fsName, fsName, fsName); | 98 fsName, fsName, fsName); |
96 builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 99 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); |
97 builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 100 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); |
98 builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, | 101 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, |
99 fsName, fsName); | 102 fsName, fsName); |
100 builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n"); | 103 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); |
101 builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | 104 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); |
102 // Add line below for smooth cubic ramp | 105 // Add line below for smooth cubic ramp |
103 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 106 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
104 break; | 107 break; |
105 } | 108 } |
106 case kFillBW_GrEffectEdgeType: { | 109 case kFillBW_GrEffectEdgeType: { |
107 builder->fsCodeAppendf("\t\tedgeAlpha = %s.x*%s.x - %s.y*%s.z;\n", f
sName, fsName, | 110 fsBuilder->codeAppendf("\t\tedgeAlpha = %s.x*%s.x - %s.y*%s.z;\n", f
sName, fsName, |
108 fsName, fsName); | 111 fsName, fsName); |
109 builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | 112 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); |
110 break; | 113 break; |
111 } | 114 } |
112 default: | 115 default: |
113 SkFAIL("Shouldn't get here"); | 116 SkFAIL("Shouldn't get here"); |
114 } | 117 } |
115 | 118 |
116 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 119 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
117 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 120 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
118 } | 121 } |
119 | 122 |
120 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 123 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
121 GrEffectKeyBuilder* b) { | 124 GrEffectKeyBuilder* b) { |
122 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); | 125 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); |
123 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 126 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
124 b->add32(key); | 127 b->add32(key); |
125 } | 128 } |
126 | 129 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 } | 163 } |
161 | 164 |
162 ////////////////////////////////////////////////////////////////////////////// | 165 ////////////////////////////////////////////////////////////////////////////// |
163 // Quad | 166 // Quad |
164 ////////////////////////////////////////////////////////////////////////////// | 167 ////////////////////////////////////////////////////////////////////////////// |
165 | 168 |
166 class GrGLQuadEffect : public GrGLVertexEffect { | 169 class GrGLQuadEffect : public GrGLVertexEffect { |
167 public: | 170 public: |
168 GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | 171 GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
169 | 172 |
170 virtual void emitCode(GrGLFullShaderBuilder* builder, | 173 virtual void emitCode(GrGLFullProgramBuilder* builder, |
171 const GrDrawEffect& drawEffect, | 174 const GrDrawEffect& drawEffect, |
172 const GrEffectKey& key, | 175 const GrEffectKey& key, |
173 const char* outputColor, | 176 const char* outputColor, |
174 const char* inputColor, | 177 const char* inputColor, |
175 const TransformedCoordsArray&, | 178 const TransformedCoordsArray&, |
176 const TextureSamplerArray&) SK_OVERRIDE; | 179 const TextureSamplerArray&) SK_OVERRIDE; |
177 | 180 |
178 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); | 181 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
179 | 182 |
180 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} | 183 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} |
181 | 184 |
182 private: | 185 private: |
183 GrEffectEdgeType fEdgeType; | 186 GrEffectEdgeType fEdgeType; |
184 | 187 |
185 typedef GrGLVertexEffect INHERITED; | 188 typedef GrGLVertexEffect INHERITED; |
186 }; | 189 }; |
187 | 190 |
188 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory, | 191 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory, |
189 const GrDrawEffect& drawEffect) | 192 const GrDrawEffect& drawEffect) |
190 : INHERITED (factory) { | 193 : INHERITED (factory) { |
191 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); | 194 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); |
192 fEdgeType = ce.getEdgeType(); | 195 fEdgeType = ce.getEdgeType(); |
193 } | 196 } |
194 | 197 |
195 void GrGLQuadEffect::emitCode(GrGLFullShaderBuilder* builder, | 198 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder, |
196 const GrDrawEffect& drawEffect, | 199 const GrDrawEffect& drawEffect, |
197 const GrEffectKey& key, | 200 const GrEffectKey& key, |
198 const char* outputColor, | 201 const char* outputColor, |
199 const char* inputColor, | 202 const char* inputColor, |
200 const TransformedCoordsArray&, | 203 const TransformedCoordsArray&, |
201 const TextureSamplerArray& samplers) { | 204 const TextureSamplerArray& samplers) { |
202 const char *vsName, *fsName; | 205 const char *vsName, *fsName; |
| 206 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); |
203 | 207 |
| 208 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
204 const SkString* attrName = | 209 const SkString* attrName = |
205 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); | 210 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
206 builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n"); | 211 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); |
207 | 212 |
208 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); | 213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 214 fsBuilder->codeAppendf("\t\tfloat edgeAlpha;\n"); |
209 | 215 |
210 switch (fEdgeType) { | 216 switch (fEdgeType) { |
211 case kHairlineAA_GrEffectEdgeType: { | 217 case kHairlineAA_GrEffectEdgeType: { |
212 SkAssertResult(builder->enableFeature( | 218 SkAssertResult(fsBuilder->enableFeature( |
213 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
214 builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); | 220 fsBuilder->codeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); |
215 builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); | 221 fsBuilder->codeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); |
216 builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" | 222 fsBuilder->codeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" |
217 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", | 223 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", |
218 fsName, fsName); | 224 fsName, fsName); |
219 builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 225 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, |
220 fsName); | 226 fsName); |
221 builder->fsCodeAppend("\t\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / do
t(gF, gF));\n"); | 227 fsBuilder->codeAppend("\t\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / do
t(gF, gF));\n"); |
222 builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | 228 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); |
223 // Add line below for smooth cubic ramp | 229 // Add line below for smooth cubic ramp |
224 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 230 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
225 break; | 231 break; |
226 } | 232 } |
227 case kFillAA_GrEffectEdgeType: { | 233 case kFillAA_GrEffectEdgeType: { |
228 SkAssertResult(builder->enableFeature( | 234 SkAssertResult(fsBuilder->enableFeature( |
229 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 235 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
230 builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); | 236 fsBuilder->codeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); |
231 builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); | 237 fsBuilder->codeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); |
232 builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" | 238 fsBuilder->codeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.
y,\n" |
233 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", | 239 "\t\t 2.0*%s.x*duvdy.x - duvdy.
y);\n", |
234 fsName, fsName); | 240 fsName, fsName); |
235 builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 241 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, |
236 fsName); | 242 fsName); |
237 builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha / sqrt(dot(gF, gF))
;\n"); | 243 fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha / sqrt(dot(gF, gF))
;\n"); |
238 builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | 244 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); |
239 // Add line below for smooth cubic ramp | 245 // Add line below for smooth cubic ramp |
240 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 246 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
241 break; | 247 break; |
242 } | 248 } |
243 case kFillBW_GrEffectEdgeType: { | 249 case kFillBW_GrEffectEdgeType: { |
244 builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, | 250 fsBuilder->codeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsNa
me, fsName, |
245 fsName); | 251 fsName); |
246 builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | 252 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); |
247 break; | 253 break; |
248 } | 254 } |
249 default: | 255 default: |
250 SkFAIL("Shouldn't get here"); | 256 SkFAIL("Shouldn't get here"); |
251 } | 257 } |
252 | 258 |
253 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 259 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
254 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 260 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
255 | |
256 | |
257 builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); | |
258 } | 261 } |
259 | 262 |
260 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 263 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
261 GrEffectKeyBuilder* b) { | 264 GrEffectKeyBuilder* b) { |
262 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); | 265 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); |
263 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 266 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
264 b->add32(key); | 267 b->add32(key); |
265 } | 268 } |
266 | 269 |
267 ////////////////////////////////////////////////////////////////////////////// | 270 ////////////////////////////////////////////////////////////////////////////// |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
300 } | 303 } |
301 | 304 |
302 ////////////////////////////////////////////////////////////////////////////// | 305 ////////////////////////////////////////////////////////////////////////////// |
303 // Cubic | 306 // Cubic |
304 ////////////////////////////////////////////////////////////////////////////// | 307 ////////////////////////////////////////////////////////////////////////////// |
305 | 308 |
306 class GrGLCubicEffect : public GrGLVertexEffect { | 309 class GrGLCubicEffect : public GrGLVertexEffect { |
307 public: | 310 public: |
308 GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | 311 GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
309 | 312 |
310 virtual void emitCode(GrGLFullShaderBuilder* builder, | 313 virtual void emitCode(GrGLFullProgramBuilder* builder, |
311 const GrDrawEffect& drawEffect, | 314 const GrDrawEffect& drawEffect, |
312 const GrEffectKey& key, | 315 const GrEffectKey& key, |
313 const char* outputColor, | 316 const char* outputColor, |
314 const char* inputColor, | 317 const char* inputColor, |
315 const TransformedCoordsArray&, | 318 const TransformedCoordsArray&, |
316 const TextureSamplerArray&) SK_OVERRIDE; | 319 const TextureSamplerArray&) SK_OVERRIDE; |
317 | 320 |
318 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); | 321 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
319 | 322 |
320 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} | 323 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} |
321 | 324 |
322 private: | 325 private: |
323 GrEffectEdgeType fEdgeType; | 326 GrEffectEdgeType fEdgeType; |
324 | 327 |
325 typedef GrGLVertexEffect INHERITED; | 328 typedef GrGLVertexEffect INHERITED; |
326 }; | 329 }; |
327 | 330 |
328 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory, | 331 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory, |
329 const GrDrawEffect& drawEffect) | 332 const GrDrawEffect& drawEffect) |
330 : INHERITED (factory) { | 333 : INHERITED (factory) { |
331 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); | 334 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); |
332 fEdgeType = ce.getEdgeType(); | 335 fEdgeType = ce.getEdgeType(); |
333 } | 336 } |
334 | 337 |
335 void GrGLCubicEffect::emitCode(GrGLFullShaderBuilder* builder, | 338 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder, |
336 const GrDrawEffect& drawEffect, | 339 const GrDrawEffect& drawEffect, |
337 const GrEffectKey& key, | 340 const GrEffectKey& key, |
338 const char* outputColor, | 341 const char* outputColor, |
339 const char* inputColor, | 342 const char* inputColor, |
340 const TransformedCoordsArray&, | 343 const TransformedCoordsArray&, |
341 const TextureSamplerArray& samplers) { | 344 const TextureSamplerArray& samplers) { |
342 const char *vsName, *fsName; | 345 const char *vsName, *fsName; |
343 | 346 |
344 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", | 347 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", |
345 &vsName, &fsName); | 348 &vsName, &fsName); |
| 349 |
| 350 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
346 const SkString* attr0Name = | 351 const SkString* attr0Name = |
347 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); | 352 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
348 builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); | 353 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); |
349 | 354 |
350 builder->fsCodeAppend("\t\tfloat edgeAlpha;\n"); | 355 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 356 fsBuilder->codeAppend("\t\tfloat edgeAlpha;\n"); |
351 | 357 |
352 switch (fEdgeType) { | 358 switch (fEdgeType) { |
353 case kHairlineAA_GrEffectEdgeType: { | 359 case kHairlineAA_GrEffectEdgeType: { |
354 SkAssertResult(builder->enableFeature( | 360 SkAssertResult(fsBuilder->enableFeature( |
355 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 361 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
356 builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 362 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); |
357 builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 363 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); |
358 builder->fsCodeAppendf("\t\tfloat dfdx =\n" | 364 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" |
359 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", | 365 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", |
360 fsName, fsName, fsName, fsName); | 366 fsName, fsName, fsName, fsName); |
361 builder->fsCodeAppendf("\t\tfloat dfdy =\n" | 367 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" |
362 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", | 368 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", |
363 fsName, fsName, fsName, fsName); | 369 fsName, fsName, fsName, fsName); |
364 builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 370 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); |
365 builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 371 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); |
366 builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", | 372 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", |
367 fsName, fsName, fsName, fsName, fsName); | 373 fsName, fsName, fsName, fsName, fsName); |
368 builder->fsCodeAppend("\t\tfunc = abs(func);\n"); | 374 fsBuilder->codeAppend("\t\tfunc = abs(func);\n"); |
369 builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n"); | 375 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); |
370 builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); | 376 fsBuilder->codeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n"
); |
371 // Add line below for smooth cubic ramp | 377 // Add line below for smooth cubic ramp |
372 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 378 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
373 break; | 379 break; |
374 } | 380 } |
375 case kFillAA_GrEffectEdgeType: { | 381 case kFillAA_GrEffectEdgeType: { |
376 SkAssertResult(builder->enableFeature( | 382 SkAssertResult(fsBuilder->enableFeature( |
377 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); | 383 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
378 builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); | 384 fsBuilder->codeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName); |
379 builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); | 385 fsBuilder->codeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName); |
380 builder->fsCodeAppendf("\t\tfloat dfdx =\n" | 386 fsBuilder->codeAppendf("\t\tfloat dfdx =\n" |
381 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", | 387 "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z -
%s.z*dklmdx.y;\n", |
382 fsName, fsName, fsName, fsName); | 388 fsName, fsName, fsName, fsName); |
383 builder->fsCodeAppendf("\t\tfloat dfdy =\n" | 389 fsBuilder->codeAppendf("\t\tfloat dfdy =\n" |
384 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", | 390 "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z -
%s.z*dklmdy.y;\n", |
385 fsName, fsName, fsName, fsName); | 391 fsName, fsName, fsName, fsName); |
386 builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); | 392 fsBuilder->codeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n"); |
387 builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); | 393 fsBuilder->codeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n"); |
388 builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", | 394 fsBuilder->codeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;
\n", |
389 fsName, fsName, fsName, fsName, fsName); | 395 fsName, fsName, fsName, fsName, fsName); |
390 builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n"); | 396 fsBuilder->codeAppend("\t\tedgeAlpha = func / gFM;\n"); |
391 builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); | 397 fsBuilder->codeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1
.0);\n"); |
392 // Add line below for smooth cubic ramp | 398 // Add line below for smooth cubic ramp |
393 // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); | 399 // fsBuilder->codeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2
.0*edgeAlpha);\n"); |
394 break; | 400 break; |
395 } | 401 } |
396 case kFillBW_GrEffectEdgeType: { | 402 case kFillBW_GrEffectEdgeType: { |
397 builder->fsCodeAppendf("\t\tedgeAlpha = %s.x*%s.x*%s.x - %s.y*%s.z;\
n", | 403 fsBuilder->codeAppendf("\t\tedgeAlpha = %s.x*%s.x*%s.x - %s.y*%s.z;\
n", |
398 fsName, fsName, fsName, fsName, fsName); | 404 fsName, fsName, fsName, fsName, fsName); |
399 builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); | 405 fsBuilder->codeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n"); |
400 break; | 406 break; |
401 } | 407 } |
402 default: | 408 default: |
403 SkFAIL("Shouldn't get here"); | 409 SkFAIL("Shouldn't get here"); |
404 } | 410 } |
405 | 411 |
406 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 412 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
407 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 413 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
408 } | 414 } |
409 | 415 |
410 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 416 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
411 GrEffectKeyBuilder* b) { | 417 GrEffectKeyBuilder* b) { |
412 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); | 418 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); |
413 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 419 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
414 b->add32(key); | 420 b->add32(key); |
415 } | 421 } |
416 | 422 |
(...skipping 24 matching lines...) Expand all Loading... |
441 const GrDrawTargetCaps& caps, | 447 const GrDrawTargetCaps& caps, |
442 GrTexture*[]) { | 448 GrTexture*[]) { |
443 GrEffect* effect; | 449 GrEffect* effect; |
444 do { | 450 do { |
445 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 451 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
446 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 452 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); |
447 effect = GrCubicEffect::Create(edgeType, caps); | 453 effect = GrCubicEffect::Create(edgeType, caps); |
448 } while (NULL == effect); | 454 } while (NULL == effect); |
449 return effect; | 455 return effect; |
450 } | 456 } |
OLD | NEW |