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 "GrBezierEffect.h" | 8 #include "GrBezierEffect.h" |
9 | 9 |
10 #include "gl/GrGLProcessor.h" | 10 #include "gl/GrGLProcessor.h" |
11 #include "gl/GrGLSL.h" | 11 #include "gl/GrGLSL.h" |
12 #include "gl/GrGLGeometryProcessor.h" | 12 #include "gl/GrGLGeometryProcessor.h" |
13 #include "gl/builders/GrGLProgramBuilder.h" | 13 #include "gl/builders/GrGLProgramBuilder.h" |
14 | 14 |
15 struct ConicBatchTracker { | 15 struct ConicBatchTracker { |
16 GrGPInput fInputColorType; | 16 GrGPInput fInputColorType; |
17 GrColor fColor; | 17 GrColor fColor; |
18 uint8_t fCoverageScale; | 18 uint8_t fCoverageScale; |
19 bool fUsesLocalCoords; | 19 bool fUsesLocalCoords; |
20 }; | 20 }; |
21 | 21 |
22 class GrGLConicEffect : public GrGLGeometryProcessor { | 22 class GrGLConicEffect : public GrGLGeometryProcessor { |
23 public: | 23 public: |
24 GrGLConicEffect(const GrGeometryProcessor&, | 24 GrGLConicEffect(const GrGeometryProcessor&, |
25 const GrBatchTracker&); | 25 const GrBatchTracker&); |
26 | 26 |
27 void onEmitCode(EmitArgs&) SK_OVERRIDE; | 27 void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE; |
28 | 28 |
29 static inline void GenKey(const GrGeometryProcessor&, | 29 static inline void GenKey(const GrGeometryProcessor&, |
30 const GrBatchTracker&, | 30 const GrBatchTracker&, |
31 const GrGLCaps&, | 31 const GrGLCaps&, |
32 GrProcessorKeyBuilder*); | 32 GrProcessorKeyBuilder*); |
33 | 33 |
34 virtual void setData(const GrGLProgramDataManager& pdman, | 34 virtual void setData(const GrGLProgramDataManager& pdman, |
35 const GrPrimitiveProcessor& primProc, | 35 const GrPrimitiveProcessor& primProc, |
36 const GrBatchTracker& bt) SK_OVERRIDE { | 36 const GrBatchTracker& bt) SK_OVERRIDE { |
37 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); | 37 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); |
(...skipping 21 matching lines...) Expand all Loading... |
59 typedef GrGLGeometryProcessor INHERITED; | 59 typedef GrGLGeometryProcessor INHERITED; |
60 }; | 60 }; |
61 | 61 |
62 GrGLConicEffect::GrGLConicEffect(const GrGeometryProcessor& processor, | 62 GrGLConicEffect::GrGLConicEffect(const GrGeometryProcessor& processor, |
63 const GrBatchTracker& bt) | 63 const GrBatchTracker& bt) |
64 : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { | 64 : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { |
65 const GrConicEffect& ce = processor.cast<GrConicEffect>(); | 65 const GrConicEffect& ce = processor.cast<GrConicEffect>(); |
66 fEdgeType = ce.getEdgeType(); | 66 fEdgeType = ce.getEdgeType(); |
67 } | 67 } |
68 | 68 |
69 void GrGLConicEffect::onEmitCode(EmitArgs& args) { | 69 void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
70 GrGLGPBuilder* pb = args.fPB; | 70 GrGLGPBuilder* pb = args.fPB; |
71 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); | 71 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
72 const GrConicEffect& gp = args.fGP.cast<GrConicEffect>(); | 72 const GrConicEffect& gp = args.fGP.cast<GrConicEffect>(); |
73 const ConicBatchTracker& local = args.fBT.cast<ConicBatchTracker>(); | 73 const ConicBatchTracker& local = args.fBT.cast<ConicBatchTracker>(); |
74 | 74 |
75 // emit attributes | 75 // emit attributes |
76 vsBuilder->emitAttributes(gp); | 76 vsBuilder->emitAttributes(gp); |
77 | 77 |
78 GrGLVertToFrag v(kVec4f_GrSLType); | 78 GrGLVertToFrag v(kVec4f_GrSLType); |
79 args.fPB->addVarying("ConicCoeffs", &v); | 79 args.fPB->addVarying("ConicCoeffs", &v); |
80 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName); | 80 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName); |
81 | 81 |
82 // Setup pass through color | 82 // Setup pass through color |
83 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, | 83 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, |
84 &fColorUniform); | 84 &fColorUniform); |
85 | 85 |
86 // setup uniform viewMatrix | 86 // setup uniform viewMatrix |
87 this->addUniformViewMatrix(pb); | 87 this->addUniformViewMatrix(pb); |
88 | 88 |
89 // Setup position | 89 // Setup position |
90 vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", this->position(), this->uVi
ewM(), | 90 SetupPosition(vsBuilder, gpArgs, gp.inPosition()->fName, gp.viewMatrix(), th
is->uViewM()); |
91 gp.inPosition()->fName); | |
92 | 91 |
93 // emit transforms with position | 92 // emit transforms with position |
94 this->emitTransforms(pb, this->position(), gp.inPosition()->fName, gp.localM
atrix(), | 93 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->fName, gp.lo
calMatrix(), |
95 args.fTransformsIn, args.fTransformsOut); | 94 args.fTransformsIn, args.fTransformsOut); |
96 | 95 |
97 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); | 96 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
98 fsBuilder->codeAppend("float edgeAlpha;"); | 97 fsBuilder->codeAppend("float edgeAlpha;"); |
99 | 98 |
100 switch (fEdgeType) { | 99 switch (fEdgeType) { |
101 case kHairlineAA_GrProcessorEdgeType: { | 100 case kHairlineAA_GrProcessorEdgeType: { |
102 SkAssertResult(fsBuilder->enableFeature( | 101 SkAssertResult(fsBuilder->enableFeature( |
103 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 102 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
104 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", v.fsIn()); | 103 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", v.fsIn()); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
157 kFloat_GrSLType, | 156 kFloat_GrSLType, |
158 kDefault_GrSLPrecision, | 157 kDefault_GrSLPrecision, |
159 "Coverage", | 158 "Coverage", |
160 &coverageScale); | 159 &coverageScale); |
161 fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverag
e, coverageScale); | 160 fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverag
e, coverageScale); |
162 } else { | 161 } else { |
163 fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); | 162 fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); |
164 } | 163 } |
165 } | 164 } |
166 | 165 |
167 void GrGLConicEffect::GenKey(const GrGeometryProcessor& processor, | 166 void GrGLConicEffect::GenKey(const GrGeometryProcessor& gp, |
168 const GrBatchTracker& bt, | 167 const GrBatchTracker& bt, |
169 const GrGLCaps&, | 168 const GrGLCaps&, |
170 GrProcessorKeyBuilder* b) { | 169 GrProcessorKeyBuilder* b) { |
171 const GrConicEffect& ce = processor.cast<GrConicEffect>(); | 170 const GrConicEffect& ce = gp.cast<GrConicEffect>(); |
172 const ConicBatchTracker& local = bt.cast<ConicBatchTracker>(); | 171 const ConicBatchTracker& local = bt.cast<ConicBatchTracker>(); |
173 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 172 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
174 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; | 173 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; |
175 key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; | 174 key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; |
176 key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ?
0x10 : 0x0; | 175 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 :
0x0; |
| 176 key |= ComputePosKey(gp.viewMatrix()) << 5; |
177 b->add32(key); | 177 b->add32(key); |
178 } | 178 } |
179 | 179 |
180 ////////////////////////////////////////////////////////////////////////////// | 180 ////////////////////////////////////////////////////////////////////////////// |
181 | 181 |
182 GrConicEffect::~GrConicEffect() {} | 182 GrConicEffect::~GrConicEffect() {} |
183 | 183 |
184 void GrConicEffect::getGLProcessorKey(const GrBatchTracker& bt, | 184 void GrConicEffect::getGLProcessorKey(const GrBatchTracker& bt, |
185 const GrGLCaps& caps, | 185 const GrGLCaps& caps, |
186 GrProcessorKeyBuilder* b) const { | 186 GrProcessorKeyBuilder* b) const { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
255 GrColor fColor; | 255 GrColor fColor; |
256 uint8_t fCoverageScale; | 256 uint8_t fCoverageScale; |
257 bool fUsesLocalCoords; | 257 bool fUsesLocalCoords; |
258 }; | 258 }; |
259 | 259 |
260 class GrGLQuadEffect : public GrGLGeometryProcessor { | 260 class GrGLQuadEffect : public GrGLGeometryProcessor { |
261 public: | 261 public: |
262 GrGLQuadEffect(const GrGeometryProcessor&, | 262 GrGLQuadEffect(const GrGeometryProcessor&, |
263 const GrBatchTracker&); | 263 const GrBatchTracker&); |
264 | 264 |
265 void onEmitCode(EmitArgs&) SK_OVERRIDE; | 265 void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE; |
266 | 266 |
267 static inline void GenKey(const GrGeometryProcessor&, | 267 static inline void GenKey(const GrGeometryProcessor&, |
268 const GrBatchTracker&, | 268 const GrBatchTracker&, |
269 const GrGLCaps&, | 269 const GrGLCaps&, |
270 GrProcessorKeyBuilder*); | 270 GrProcessorKeyBuilder*); |
271 | 271 |
272 virtual void setData(const GrGLProgramDataManager& pdman, | 272 virtual void setData(const GrGLProgramDataManager& pdman, |
273 const GrPrimitiveProcessor& primProc, | 273 const GrPrimitiveProcessor& primProc, |
274 const GrBatchTracker& bt) SK_OVERRIDE { | 274 const GrBatchTracker& bt) SK_OVERRIDE { |
275 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); | 275 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); |
(...skipping 21 matching lines...) Expand all Loading... |
297 typedef GrGLGeometryProcessor INHERITED; | 297 typedef GrGLGeometryProcessor INHERITED; |
298 }; | 298 }; |
299 | 299 |
300 GrGLQuadEffect::GrGLQuadEffect(const GrGeometryProcessor& processor, | 300 GrGLQuadEffect::GrGLQuadEffect(const GrGeometryProcessor& processor, |
301 const GrBatchTracker& bt) | 301 const GrBatchTracker& bt) |
302 : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { | 302 : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { |
303 const GrQuadEffect& ce = processor.cast<GrQuadEffect>(); | 303 const GrQuadEffect& ce = processor.cast<GrQuadEffect>(); |
304 fEdgeType = ce.getEdgeType(); | 304 fEdgeType = ce.getEdgeType(); |
305 } | 305 } |
306 | 306 |
307 void GrGLQuadEffect::onEmitCode(EmitArgs& args) { | 307 void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
308 GrGLGPBuilder* pb = args.fPB; | 308 GrGLGPBuilder* pb = args.fPB; |
309 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); | 309 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
310 const GrQuadEffect& gp = args.fGP.cast<GrQuadEffect>(); | 310 const GrQuadEffect& gp = args.fGP.cast<GrQuadEffect>(); |
311 const QuadBatchTracker& local = args.fBT.cast<QuadBatchTracker>(); | 311 const QuadBatchTracker& local = args.fBT.cast<QuadBatchTracker>(); |
312 | 312 |
313 // emit attributes | 313 // emit attributes |
314 vsBuilder->emitAttributes(gp); | 314 vsBuilder->emitAttributes(gp); |
315 | 315 |
316 GrGLVertToFrag v(kVec4f_GrSLType); | 316 GrGLVertToFrag v(kVec4f_GrSLType); |
317 args.fPB->addVarying("HairQuadEdge", &v); | 317 args.fPB->addVarying("HairQuadEdge", &v); |
318 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName); | 318 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName); |
319 | 319 |
320 // Setup pass through color | 320 // Setup pass through color |
321 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, | 321 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, |
322 &fColorUniform); | 322 &fColorUniform); |
323 | 323 |
324 // setup uniform viewMatrix | 324 // setup uniform viewMatrix |
325 this->addUniformViewMatrix(pb); | 325 this->addUniformViewMatrix(pb); |
326 | 326 |
327 // Setup position | 327 // Setup position |
328 vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", this->position(), this->uVi
ewM(), | 328 SetupPosition(vsBuilder, gpArgs, gp.inPosition()->fName, gp.viewMatrix(), th
is->uViewM()); |
329 gp.inPosition()->fName); | |
330 | 329 |
331 // emit transforms with position | 330 // emit transforms with position |
332 this->emitTransforms(pb, this->position(), gp.inPosition()->fName, gp.localM
atrix(), | 331 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->fName, gp.lo
calMatrix(), |
333 args.fTransformsIn, args.fTransformsOut); | 332 args.fTransformsIn, args.fTransformsOut); |
334 | 333 |
335 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); | 334 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
336 fsBuilder->codeAppendf("float edgeAlpha;"); | 335 fsBuilder->codeAppendf("float edgeAlpha;"); |
337 | 336 |
338 switch (fEdgeType) { | 337 switch (fEdgeType) { |
339 case kHairlineAA_GrProcessorEdgeType: { | 338 case kHairlineAA_GrProcessorEdgeType: { |
340 SkAssertResult(fsBuilder->enableFeature( | 339 SkAssertResult(fsBuilder->enableFeature( |
341 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 340 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
342 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); | 341 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
381 kFloat_GrSLType, | 380 kFloat_GrSLType, |
382 kDefault_GrSLPrecision, | 381 kDefault_GrSLPrecision, |
383 "Coverage", | 382 "Coverage", |
384 &coverageScale); | 383 &coverageScale); |
385 fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverag
e, coverageScale); | 384 fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverag
e, coverageScale); |
386 } else { | 385 } else { |
387 fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); | 386 fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); |
388 } | 387 } |
389 } | 388 } |
390 | 389 |
391 void GrGLQuadEffect::GenKey(const GrGeometryProcessor& processor, | 390 void GrGLQuadEffect::GenKey(const GrGeometryProcessor& gp, |
392 const GrBatchTracker& bt, | 391 const GrBatchTracker& bt, |
393 const GrGLCaps&, | 392 const GrGLCaps&, |
394 GrProcessorKeyBuilder* b) { | 393 GrProcessorKeyBuilder* b) { |
395 const GrQuadEffect& ce = processor.cast<GrQuadEffect>(); | 394 const GrQuadEffect& ce = gp.cast<GrQuadEffect>(); |
396 const QuadBatchTracker& local = bt.cast<QuadBatchTracker>(); | 395 const QuadBatchTracker& local = bt.cast<QuadBatchTracker>(); |
397 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 396 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
398 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; | 397 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0; |
399 key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; | 398 key |= 0xff != local.fCoverageScale ? 0x8 : 0x0; |
400 key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ?
0x10 : 0x0; | 399 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 :
0x0; |
| 400 key |= ComputePosKey(gp.viewMatrix()) << 5; |
401 b->add32(key); | 401 b->add32(key); |
402 } | 402 } |
403 | 403 |
404 ////////////////////////////////////////////////////////////////////////////// | 404 ////////////////////////////////////////////////////////////////////////////// |
405 | 405 |
406 GrQuadEffect::~GrQuadEffect() {} | 406 GrQuadEffect::~GrQuadEffect() {} |
407 | 407 |
408 void GrQuadEffect::getGLProcessorKey(const GrBatchTracker& bt, | 408 void GrQuadEffect::getGLProcessorKey(const GrBatchTracker& bt, |
409 const GrGLCaps& caps, | 409 const GrGLCaps& caps, |
410 GrProcessorKeyBuilder* b) const { | 410 GrProcessorKeyBuilder* b) const { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
479 GrGPInput fInputColorType; | 479 GrGPInput fInputColorType; |
480 GrColor fColor; | 480 GrColor fColor; |
481 bool fUsesLocalCoords; | 481 bool fUsesLocalCoords; |
482 }; | 482 }; |
483 | 483 |
484 class GrGLCubicEffect : public GrGLGeometryProcessor { | 484 class GrGLCubicEffect : public GrGLGeometryProcessor { |
485 public: | 485 public: |
486 GrGLCubicEffect(const GrGeometryProcessor&, | 486 GrGLCubicEffect(const GrGeometryProcessor&, |
487 const GrBatchTracker&); | 487 const GrBatchTracker&); |
488 | 488 |
489 void onEmitCode(EmitArgs&) SK_OVERRIDE; | 489 void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE; |
490 | 490 |
491 static inline void GenKey(const GrGeometryProcessor&, | 491 static inline void GenKey(const GrGeometryProcessor&, |
492 const GrBatchTracker&, | 492 const GrBatchTracker&, |
493 const GrGLCaps&, | 493 const GrGLCaps&, |
494 GrProcessorKeyBuilder*); | 494 GrProcessorKeyBuilder*); |
495 | 495 |
496 virtual void setData(const GrGLProgramDataManager& pdman, | 496 virtual void setData(const GrGLProgramDataManager& pdman, |
497 const GrPrimitiveProcessor& primProc, | 497 const GrPrimitiveProcessor& primProc, |
498 const GrBatchTracker& bt) SK_OVERRIDE { | 498 const GrBatchTracker& bt) SK_OVERRIDE { |
499 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); | 499 this->setUniformViewMatrix(pdman, primProc.viewMatrix()); |
(...skipping 15 matching lines...) Expand all Loading... |
515 typedef GrGLGeometryProcessor INHERITED; | 515 typedef GrGLGeometryProcessor INHERITED; |
516 }; | 516 }; |
517 | 517 |
518 GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor, | 518 GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor, |
519 const GrBatchTracker&) | 519 const GrBatchTracker&) |
520 : fColor(GrColor_ILLEGAL) { | 520 : fColor(GrColor_ILLEGAL) { |
521 const GrCubicEffect& ce = processor.cast<GrCubicEffect>(); | 521 const GrCubicEffect& ce = processor.cast<GrCubicEffect>(); |
522 fEdgeType = ce.getEdgeType(); | 522 fEdgeType = ce.getEdgeType(); |
523 } | 523 } |
524 | 524 |
525 void GrGLCubicEffect::onEmitCode(EmitArgs& args) { | 525 void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
526 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); | 526 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
527 const GrCubicEffect& gp = args.fGP.cast<GrCubicEffect>(); | 527 const GrCubicEffect& gp = args.fGP.cast<GrCubicEffect>(); |
528 const CubicBatchTracker& local = args.fBT.cast<CubicBatchTracker>(); | 528 const CubicBatchTracker& local = args.fBT.cast<CubicBatchTracker>(); |
529 | 529 |
530 // emit attributes | 530 // emit attributes |
531 vsBuilder->emitAttributes(gp); | 531 vsBuilder->emitAttributes(gp); |
532 | 532 |
533 GrGLVertToFrag v(kVec4f_GrSLType); | 533 GrGLVertToFrag v(kVec4f_GrSLType); |
534 args.fPB->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision); | 534 args.fPB->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision); |
535 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inCubicCoeffs()->fName); | 535 vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inCubicCoeffs()->fName); |
536 | 536 |
537 // Setup pass through color | 537 // Setup pass through color |
538 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, | 538 this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputCol
or, NULL, |
539 &fColorUniform); | 539 &fColorUniform); |
540 | 540 |
541 // setup uniform viewMatrix | 541 // setup uniform viewMatrix |
542 this->addUniformViewMatrix(args.fPB); | 542 this->addUniformViewMatrix(args.fPB); |
543 | 543 |
544 // Setup position | 544 // Setup position |
545 vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", this->position(), this->uVi
ewM(), | 545 SetupPosition(vsBuilder, gpArgs, gp.inPosition()->fName, gp.viewMatrix(), th
is->uViewM()); |
546 gp.inPosition()->fName); | |
547 | 546 |
548 // emit transforms with position | 547 // emit transforms with position |
549 this->emitTransforms(args.fPB, this->position(), gp.inPosition()->fName, gp.
localMatrix(), | 548 this->emitTransforms(args.fPB, gpArgs->fPositionVar, gp.inPosition()->fName,
gp.localMatrix(), |
550 args.fTransformsIn, args.fTransformsOut); | 549 args.fTransformsIn, args.fTransformsOut); |
551 | 550 |
552 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); | 551 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
553 | 552 |
554 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, kHigh_GrSLPrecision
); | 553 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, kHigh_GrSLPrecision
); |
555 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, kHigh_GrSLPrecision); | 554 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, kHigh_GrSLPrecision); |
556 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, kHigh_GrSLPrecision); | 555 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, kHigh_GrSLPrecision); |
557 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, kHigh_GrSLPrecision); | 556 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, kHigh_GrSLPrecision); |
558 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, kHigh_GrSLPrecision); | 557 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, kHigh_GrSLPrecision); |
559 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, kHigh_GrSLPrecision); | 558 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, kHigh_GrSLPrecision); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
629 break; | 628 break; |
630 } | 629 } |
631 default: | 630 default: |
632 SkFAIL("Shouldn't get here"); | 631 SkFAIL("Shouldn't get here"); |
633 } | 632 } |
634 | 633 |
635 | 634 |
636 fsBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_s
tr()); | 635 fsBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_s
tr()); |
637 } | 636 } |
638 | 637 |
639 void GrGLCubicEffect::GenKey(const GrGeometryProcessor& processor, | 638 void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp, |
640 const GrBatchTracker& bt, | 639 const GrBatchTracker& bt, |
641 const GrGLCaps&, | 640 const GrGLCaps&, |
642 GrProcessorKeyBuilder* b) { | 641 GrProcessorKeyBuilder* b) { |
643 const GrCubicEffect& ce = processor.cast<GrCubicEffect>(); | 642 const GrCubicEffect& ce = gp.cast<GrCubicEffect>(); |
644 const CubicBatchTracker& local = bt.cast<CubicBatchTracker>(); | 643 const CubicBatchTracker& local = bt.cast<CubicBatchTracker>(); |
645 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; | 644 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
646 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x8; | 645 key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x8; |
647 key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ?
0x10 : 0x0; | 646 key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x10 :
0x0; |
| 647 key |= ComputePosKey(gp.viewMatrix()) << 5; |
648 b->add32(key); | 648 b->add32(key); |
649 } | 649 } |
650 | 650 |
651 ////////////////////////////////////////////////////////////////////////////// | 651 ////////////////////////////////////////////////////////////////////////////// |
652 | 652 |
653 GrCubicEffect::~GrCubicEffect() {} | 653 GrCubicEffect::~GrCubicEffect() {} |
654 | 654 |
655 void GrCubicEffect::getGLProcessorKey(const GrBatchTracker& bt, | 655 void GrCubicEffect::getGLProcessorKey(const GrBatchTracker& bt, |
656 const GrGLCaps& caps, | 656 const GrGLCaps& caps, |
657 GrProcessorKeyBuilder* b) const { | 657 GrProcessorKeyBuilder* b) const { |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
705 GrGeometryProcessor* gp; | 705 GrGeometryProcessor* gp; |
706 do { | 706 do { |
707 GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>( | 707 GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>( |
708 random->nextULessThan(kGrPro
cessorEdgeTypeCnt)); | 708 random->nextULessThan(kGrPro
cessorEdgeTypeCnt)); |
709 gp = GrCubicEffect::Create(GrRandomColor(random), | 709 gp = GrCubicEffect::Create(GrRandomColor(random), |
710 GrProcessorUnitTest::TestMatrix(random), edge
Type, caps); | 710 GrProcessorUnitTest::TestMatrix(random), edge
Type, caps); |
711 } while (NULL == gp); | 711 } while (NULL == gp); |
712 return gp; | 712 return gp; |
713 } | 713 } |
714 | 714 |
OLD | NEW |