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 |
11 #include "gl/GrGLEffect.h" | 11 #include "gl/GrGLEffect.h" |
12 #include "gl/GrGLSL.h" | 12 #include "gl/GrGLSL.h" |
13 #include "gl/GrGLGeometryProcessor.h" | 13 #include "gl/GrGLGeometryProcessor.h" |
14 #include "GrTBackendEffectFactory.h" | 14 #include "GrTBackendEffectFactory.h" |
15 | 15 |
16 class GrGLConicEffect : public GrGLGeometryProcessor { | 16 class GrGLConicEffect : public GrGLGeometryProcessor { |
17 public: | 17 public: |
18 GrGLConicEffect(const GrBackendEffectFactory&, const GrEffect&); | 18 GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
19 | 19 |
20 virtual void emitCode(GrGLFullProgramBuilder* builder, | 20 virtual void emitCode(GrGLFullProgramBuilder* builder, |
21 const GrEffect& effect, | 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 GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 28 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
29 | 29 |
30 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 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 GrGLGeometryProcessor INHERITED; | 35 typedef GrGLGeometryProcessor INHERITED; |
36 }; | 36 }; |
37 | 37 |
38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory, | 38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory, |
39 const GrEffect& effect) | 39 const GrDrawEffect& drawEffect) |
40 : INHERITED (factory) { | 40 : INHERITED (factory) { |
41 const GrConicEffect& ce = effect.cast<GrConicEffect>(); | 41 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); |
42 fEdgeType = ce.getEdgeType(); | 42 fEdgeType = ce.getEdgeType(); |
43 } | 43 } |
44 | 44 |
45 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder, | 45 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder, |
46 const GrEffect& effect, | 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 | 56 |
57 const GrShaderVar& inConicCoeffs = effect.cast<GrConicEffect>().inConicCoeff
s(); | 57 const GrShaderVar& inConicCoeffs = drawEffect.castEffect<GrConicEffect>().in
ConicCoeffs(); |
58 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 58 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
59 vsBuilder->codeAppendf("%s = %s;", vsName, inConicCoeffs.c_str()); | 59 vsBuilder->codeAppendf("%s = %s;", vsName, inConicCoeffs.c_str()); |
60 | 60 |
61 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 61 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
62 fsBuilder->codeAppend("float edgeAlpha;"); | 62 fsBuilder->codeAppend("float edgeAlpha;"); |
63 | 63 |
64 switch (fEdgeType) { | 64 switch (fEdgeType) { |
65 case kHairlineAA_GrEffectEdgeType: { | 65 case kHairlineAA_GrEffectEdgeType: { |
66 SkAssertResult(fsBuilder->enableFeature( | 66 SkAssertResult(fsBuilder->enableFeature( |
67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
112 break; | 112 break; |
113 } | 113 } |
114 default: | 114 default: |
115 SkFAIL("Shouldn't get here"); | 115 SkFAIL("Shouldn't get here"); |
116 } | 116 } |
117 | 117 |
118 fsBuilder->codeAppendf("%s = %s;", outputColor, | 118 fsBuilder->codeAppendf("%s = %s;", outputColor, |
119 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 119 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
120 } | 120 } |
121 | 121 |
122 void GrGLConicEffect::GenKey(const GrEffect& effect, const GrGLCaps&, | 122 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
123 GrEffectKeyBuilder* b) { | 123 GrEffectKeyBuilder* b) { |
124 const GrConicEffect& ce = effect.cast<GrConicEffect>(); | 124 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); |
125 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 125 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
126 b->add32(key); | 126 b->add32(key); |
127 } | 127 } |
128 | 128 |
129 ////////////////////////////////////////////////////////////////////////////// | 129 ////////////////////////////////////////////////////////////////////////////// |
130 | 130 |
131 GrConicEffect::~GrConicEffect() {} | 131 GrConicEffect::~GrConicEffect() {} |
132 | 132 |
133 const GrBackendEffectFactory& GrConicEffect::getFactory() const { | 133 const GrBackendEffectFactory& GrConicEffect::getFactory() const { |
134 return GrTBackendEffectFactory<GrConicEffect>::getInstance(); | 134 return GrTBackendEffectFactory<GrConicEffect>::getInstance(); |
135 } | 135 } |
136 | 136 |
137 GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) | 137 GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) |
138 : fEdgeType(edgeType) | 138 : fEdgeType(edgeType) |
139 , fInConicCoeffs(this->addVertexAttrib(GrShaderVar("inConicCoeffs", | 139 , fInConicCoeffs(this->addVertexAttrib(GrShaderVar("inConicCoeffs", |
140 kVec4f_GrSLType, | 140 kVec4f_GrSLType, |
141 GrShaderVar::kAttribute_T
ypeModifier))) { | 141 GrShaderVar::kAttribute_T
ypeModifier))) { |
142 } | 142 } |
143 | 143 |
144 bool GrConicEffect::onIsEqual(const GrEffect& other) const { | 144 bool GrConicEffect::onIsEqual(const GrEffect& other) const { |
145 const GrConicEffect& ce = other.cast<GrConicEffect>(); | 145 const GrConicEffect& ce = CastEffect<GrConicEffect>(other); |
146 return (ce.fEdgeType == fEdgeType); | 146 return (ce.fEdgeType == fEdgeType); |
147 } | 147 } |
148 | 148 |
149 ////////////////////////////////////////////////////////////////////////////// | 149 ////////////////////////////////////////////////////////////////////////////// |
150 | 150 |
151 GR_DEFINE_EFFECT_TEST(GrConicEffect); | 151 GR_DEFINE_EFFECT_TEST(GrConicEffect); |
152 | 152 |
153 GrEffect* GrConicEffect::TestCreate(SkRandom* random, | 153 GrEffect* GrConicEffect::TestCreate(SkRandom* random, |
154 GrContext*, | 154 GrContext*, |
155 const GrDrawTargetCaps& caps, | 155 const GrDrawTargetCaps& caps, |
156 GrTexture*[]) { | 156 GrTexture*[]) { |
157 GrEffect* effect; | 157 GrEffect* effect; |
158 do { | 158 do { |
159 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 159 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
160 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 160 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); |
161 effect = GrConicEffect::Create(edgeType, caps); | 161 effect = GrConicEffect::Create(edgeType, caps); |
162 } while (NULL == effect); | 162 } while (NULL == effect); |
163 return effect; | 163 return effect; |
164 } | 164 } |
165 | 165 |
166 ////////////////////////////////////////////////////////////////////////////// | 166 ////////////////////////////////////////////////////////////////////////////// |
167 // Quad | 167 // Quad |
168 ////////////////////////////////////////////////////////////////////////////// | 168 ////////////////////////////////////////////////////////////////////////////// |
169 | 169 |
170 class GrGLQuadEffect : public GrGLGeometryProcessor { | 170 class GrGLQuadEffect : public GrGLGeometryProcessor { |
171 public: | 171 public: |
172 GrGLQuadEffect(const GrBackendEffectFactory&, const GrEffect&); | 172 GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
173 | 173 |
174 virtual void emitCode(GrGLFullProgramBuilder* builder, | 174 virtual void emitCode(GrGLFullProgramBuilder* builder, |
175 const GrEffect& effect, | 175 const GrDrawEffect& drawEffect, |
176 const GrEffectKey& key, | 176 const GrEffectKey& key, |
177 const char* outputColor, | 177 const char* outputColor, |
178 const char* inputColor, | 178 const char* inputColor, |
179 const TransformedCoordsArray&, | 179 const TransformedCoordsArray&, |
180 const TextureSamplerArray&) SK_OVERRIDE; | 180 const TextureSamplerArray&) SK_OVERRIDE; |
181 | 181 |
182 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 182 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
183 | 183 |
184 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 184 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} |
185 | 185 |
186 private: | 186 private: |
187 GrEffectEdgeType fEdgeType; | 187 GrEffectEdgeType fEdgeType; |
188 | 188 |
189 typedef GrGLGeometryProcessor INHERITED; | 189 typedef GrGLGeometryProcessor INHERITED; |
190 }; | 190 }; |
191 | 191 |
192 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory, | 192 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory, |
193 const GrEffect& effect) | 193 const GrDrawEffect& drawEffect) |
194 : INHERITED (factory) { | 194 : INHERITED (factory) { |
195 const GrQuadEffect& ce = effect.cast<GrQuadEffect>(); | 195 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); |
196 fEdgeType = ce.getEdgeType(); | 196 fEdgeType = ce.getEdgeType(); |
197 } | 197 } |
198 | 198 |
199 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder, | 199 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder, |
200 const GrEffect& effect, | 200 const GrDrawEffect& drawEffect, |
201 const GrEffectKey& key, | 201 const GrEffectKey& key, |
202 const char* outputColor, | 202 const char* outputColor, |
203 const char* inputColor, | 203 const char* inputColor, |
204 const TransformedCoordsArray&, | 204 const TransformedCoordsArray&, |
205 const TextureSamplerArray& samplers) { | 205 const TextureSamplerArray& samplers) { |
206 const char *vsName, *fsName; | 206 const char *vsName, *fsName; |
207 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); | 207 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); |
208 | 208 |
209 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 209 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
210 const GrShaderVar& inHairQuadEdge = effect.cast<GrQuadEffect>().inHairQuadEd
ge(); | 210 const GrShaderVar& inHairQuadEdge = drawEffect.castEffect<GrQuadEffect>().in
HairQuadEdge(); |
211 vsBuilder->codeAppendf("%s = %s;", vsName, inHairQuadEdge.c_str()); | 211 vsBuilder->codeAppendf("%s = %s;", vsName, inHairQuadEdge.c_str()); |
212 | 212 |
213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
214 fsBuilder->codeAppendf("float edgeAlpha;"); | 214 fsBuilder->codeAppendf("float edgeAlpha;"); |
215 | 215 |
216 switch (fEdgeType) { | 216 switch (fEdgeType) { |
217 case kHairlineAA_GrEffectEdgeType: { | 217 case kHairlineAA_GrEffectEdgeType: { |
218 SkAssertResult(fsBuilder->enableFeature( | 218 SkAssertResult(fsBuilder->enableFeature( |
219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
220 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); | 220 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); |
(...skipping 29 matching lines...) Expand all Loading... |
250 break; | 250 break; |
251 } | 251 } |
252 default: | 252 default: |
253 SkFAIL("Shouldn't get here"); | 253 SkFAIL("Shouldn't get here"); |
254 } | 254 } |
255 | 255 |
256 fsBuilder->codeAppendf("%s = %s;", outputColor, | 256 fsBuilder->codeAppendf("%s = %s;", outputColor, |
257 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); | 257 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).
c_str()); |
258 } | 258 } |
259 | 259 |
260 void GrGLQuadEffect::GenKey(const GrEffect& effect, const GrGLCaps&, | 260 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
261 GrEffectKeyBuilder* b) { | 261 GrEffectKeyBuilder* b) { |
262 const GrQuadEffect& ce = effect.cast<GrQuadEffect>(); | 262 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); |
263 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 263 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
264 b->add32(key); | 264 b->add32(key); |
265 } | 265 } |
266 | 266 |
267 ////////////////////////////////////////////////////////////////////////////// | 267 ////////////////////////////////////////////////////////////////////////////// |
268 | 268 |
269 GrQuadEffect::~GrQuadEffect() {} | 269 GrQuadEffect::~GrQuadEffect() {} |
270 | 270 |
271 const GrBackendEffectFactory& GrQuadEffect::getFactory() const { | 271 const GrBackendEffectFactory& GrQuadEffect::getFactory() const { |
272 return GrTBackendEffectFactory<GrQuadEffect>::getInstance(); | 272 return GrTBackendEffectFactory<GrQuadEffect>::getInstance(); |
273 } | 273 } |
274 | 274 |
275 GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) | 275 GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) |
276 : fEdgeType(edgeType) | 276 : fEdgeType(edgeType) |
277 , fInHairQuadEdge(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", | 277 , fInHairQuadEdge(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", |
278 kVec4f_GrSLType, | 278 kVec4f_GrSLType, |
279 GrShaderVar::kAttribute_
TypeModifier))) { | 279 GrShaderVar::kAttribute_
TypeModifier))) { |
280 } | 280 } |
281 | 281 |
282 bool GrQuadEffect::onIsEqual(const GrEffect& other) const { | 282 bool GrQuadEffect::onIsEqual(const GrEffect& other) const { |
283 const GrQuadEffect& ce = other.cast<GrQuadEffect>(); | 283 const GrQuadEffect& ce = CastEffect<GrQuadEffect>(other); |
284 return (ce.fEdgeType == fEdgeType); | 284 return (ce.fEdgeType == fEdgeType); |
285 } | 285 } |
286 | 286 |
287 ////////////////////////////////////////////////////////////////////////////// | 287 ////////////////////////////////////////////////////////////////////////////// |
288 | 288 |
289 GR_DEFINE_EFFECT_TEST(GrQuadEffect); | 289 GR_DEFINE_EFFECT_TEST(GrQuadEffect); |
290 | 290 |
291 GrEffect* GrQuadEffect::TestCreate(SkRandom* random, | 291 GrEffect* GrQuadEffect::TestCreate(SkRandom* random, |
292 GrContext*, | 292 GrContext*, |
293 const GrDrawTargetCaps& caps, | 293 const GrDrawTargetCaps& caps, |
294 GrTexture*[]) { | 294 GrTexture*[]) { |
295 GrEffect* effect; | 295 GrEffect* effect; |
296 do { | 296 do { |
297 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 297 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
298 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 298 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); |
299 effect = GrQuadEffect::Create(edgeType, caps); | 299 effect = GrQuadEffect::Create(edgeType, caps); |
300 } while (NULL == effect); | 300 } while (NULL == effect); |
301 return effect; | 301 return effect; |
302 } | 302 } |
303 | 303 |
304 ////////////////////////////////////////////////////////////////////////////// | 304 ////////////////////////////////////////////////////////////////////////////// |
305 // Cubic | 305 // Cubic |
306 ////////////////////////////////////////////////////////////////////////////// | 306 ////////////////////////////////////////////////////////////////////////////// |
307 | 307 |
308 class GrGLCubicEffect : public GrGLGeometryProcessor { | 308 class GrGLCubicEffect : public GrGLGeometryProcessor { |
309 public: | 309 public: |
310 GrGLCubicEffect(const GrBackendEffectFactory&, const GrEffect&); | 310 GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
311 | 311 |
312 virtual void emitCode(GrGLFullProgramBuilder* builder, | 312 virtual void emitCode(GrGLFullProgramBuilder* builder, |
313 const GrEffect& effect, | 313 const GrDrawEffect& drawEffect, |
314 const GrEffectKey& key, | 314 const GrEffectKey& key, |
315 const char* outputColor, | 315 const char* outputColor, |
316 const char* inputColor, | 316 const char* inputColor, |
317 const TransformedCoordsArray&, | 317 const TransformedCoordsArray&, |
318 const TextureSamplerArray&) SK_OVERRIDE; | 318 const TextureSamplerArray&) SK_OVERRIDE; |
319 | 319 |
320 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 320 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
321 | 321 |
322 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 322 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE {} |
323 | 323 |
324 private: | 324 private: |
325 GrEffectEdgeType fEdgeType; | 325 GrEffectEdgeType fEdgeType; |
326 | 326 |
327 typedef GrGLGeometryProcessor INHERITED; | 327 typedef GrGLGeometryProcessor INHERITED; |
328 }; | 328 }; |
329 | 329 |
330 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory, | 330 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory, |
331 const GrEffect& effect) | 331 const GrDrawEffect& drawEffect) |
332 : INHERITED (factory) { | 332 : INHERITED (factory) { |
333 const GrCubicEffect& ce = effect.cast<GrCubicEffect>(); | 333 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); |
334 fEdgeType = ce.getEdgeType(); | 334 fEdgeType = ce.getEdgeType(); |
335 } | 335 } |
336 | 336 |
337 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder, | 337 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder, |
338 const GrEffect& effect, | 338 const GrDrawEffect& drawEffect, |
339 const GrEffectKey& key, | 339 const GrEffectKey& key, |
340 const char* outputColor, | 340 const char* outputColor, |
341 const char* inputColor, | 341 const char* inputColor, |
342 const TransformedCoordsArray&, | 342 const TransformedCoordsArray&, |
343 const TextureSamplerArray& samplers) { | 343 const TextureSamplerArray& samplers) { |
344 const char *vsName, *fsName; | 344 const char *vsName, *fsName; |
345 | 345 |
346 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", | 346 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", |
347 &vsName, &fsName, GrGLShaderVar::kHigh_Precision); | 347 &vsName, &fsName, GrGLShaderVar::kHigh_Precision); |
348 | 348 |
349 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 349 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
350 const GrShaderVar& inCubicCoeffs = effect.cast<GrCubicEffect>().inCubicCoeff
s(); | 350 const GrShaderVar& inCubicCoeffs = drawEffect.castEffect<GrCubicEffect>().in
CubicCoeffs(); |
351 vsBuilder->codeAppendf("%s = %s;", vsName, inCubicCoeffs.c_str()); | 351 vsBuilder->codeAppendf("%s = %s;", vsName, inCubicCoeffs.c_str()); |
352 | 352 |
353 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 353 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
354 | 354 |
355 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHig
h_Precision); | 355 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHig
h_Precision); |
356 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); | 356 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); |
357 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); | 357 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec
ision); |
358 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); | 358 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
359 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); | 359 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
360 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision); | 360 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
430 break; | 430 break; |
431 } | 431 } |
432 default: | 432 default: |
433 SkFAIL("Shouldn't get here"); | 433 SkFAIL("Shouldn't get here"); |
434 } | 434 } |
435 | 435 |
436 fsBuilder->codeAppendf("%s = %s;", outputColor, | 436 fsBuilder->codeAppendf("%s = %s;", outputColor, |
437 (GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_st
r())).c_str()); | 437 (GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_st
r())).c_str()); |
438 } | 438 } |
439 | 439 |
440 void GrGLCubicEffect::GenKey(const GrEffect& effect, const GrGLCaps&, | 440 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
441 GrEffectKeyBuilder* b) { | 441 GrEffectKeyBuilder* b) { |
442 const GrCubicEffect& ce = effect.cast<GrCubicEffect>(); | 442 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); |
443 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 443 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
444 b->add32(key); | 444 b->add32(key); |
445 } | 445 } |
446 | 446 |
447 ////////////////////////////////////////////////////////////////////////////// | 447 ////////////////////////////////////////////////////////////////////////////// |
448 | 448 |
449 GrCubicEffect::~GrCubicEffect() {} | 449 GrCubicEffect::~GrCubicEffect() {} |
450 | 450 |
451 const GrBackendEffectFactory& GrCubicEffect::getFactory() const { | 451 const GrBackendEffectFactory& GrCubicEffect::getFactory() const { |
452 return GrTBackendEffectFactory<GrCubicEffect>::getInstance(); | 452 return GrTBackendEffectFactory<GrCubicEffect>::getInstance(); |
453 } | 453 } |
454 | 454 |
455 GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) | 455 GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) |
456 : fEdgeType(edgeType) | 456 : fEdgeType(edgeType) |
457 , fInCubicCoeffs(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", | 457 , fInCubicCoeffs(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", |
458 kVec4f_GrSLType, | 458 kVec4f_GrSLType, |
459 GrShaderVar::kAttribute_T
ypeModifier))) { | 459 GrShaderVar::kAttribute_T
ypeModifier))) { |
460 } | 460 } |
461 | 461 |
462 bool GrCubicEffect::onIsEqual(const GrEffect& other) const { | 462 bool GrCubicEffect::onIsEqual(const GrEffect& other) const { |
463 const GrCubicEffect& ce = other.cast<GrCubicEffect>(); | 463 const GrCubicEffect& ce = CastEffect<GrCubicEffect>(other); |
464 return (ce.fEdgeType == fEdgeType); | 464 return (ce.fEdgeType == fEdgeType); |
465 } | 465 } |
466 | 466 |
467 ////////////////////////////////////////////////////////////////////////////// | 467 ////////////////////////////////////////////////////////////////////////////// |
468 | 468 |
469 GR_DEFINE_EFFECT_TEST(GrCubicEffect); | 469 GR_DEFINE_EFFECT_TEST(GrCubicEffect); |
470 | 470 |
471 GrEffect* GrCubicEffect::TestCreate(SkRandom* random, | 471 GrEffect* GrCubicEffect::TestCreate(SkRandom* random, |
472 GrContext*, | 472 GrContext*, |
473 const GrDrawTargetCaps& caps, | 473 const GrDrawTargetCaps& caps, |
474 GrTexture*[]) { | 474 GrTexture*[]) { |
475 GrEffect* effect; | 475 GrEffect* effect; |
476 do { | 476 do { |
477 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 477 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
478 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 478 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); |
479 effect = GrCubicEffect::Create(edgeType, caps); | 479 effect = GrCubicEffect::Create(edgeType, caps); |
480 } while (NULL == effect); | 480 } while (NULL == effect); |
481 return effect; | 481 return effect; |
482 } | 482 } |
483 | 483 |
OLD | NEW |