OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 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 "GrDashingEffect.h" | 8 #include "GrDashingEffect.h" |
9 | 9 |
10 #include "../GrAARectRenderer.h" | 10 #include "../GrAARectRenderer.h" |
(...skipping 464 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
475 | 475 |
476 typedef GrGeometryProcessor INHERITED; | 476 typedef GrGeometryProcessor INHERITED; |
477 }; | 477 }; |
478 | 478 |
479 ////////////////////////////////////////////////////////////////////////////// | 479 ////////////////////////////////////////////////////////////////////////////// |
480 | 480 |
481 class GLDashingCircleEffect : public GrGLGeometryProcessor { | 481 class GLDashingCircleEffect : public GrGLGeometryProcessor { |
482 public: | 482 public: |
483 GLDashingCircleEffect(const GrBackendProcessorFactory&, const GrProcessor&); | 483 GLDashingCircleEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
484 | 484 |
485 virtual void emitCode(GrGLGPBuilder* builder, | 485 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; |
486 const GrGeometryProcessor& geometryProcessor, | |
487 const GrProcessorKey& key, | |
488 const char* outputColor, | |
489 const char* inputColor, | |
490 const TransformedCoordsArray&, | |
491 const TextureSamplerArray&) SK_OVERRIDE; | |
492 | 486 |
493 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 487 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
494 | 488 |
495 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 489 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
496 | 490 |
497 private: | 491 private: |
498 GrGLProgramDataManager::UniformHandle fParamUniform; | 492 GrGLProgramDataManager::UniformHandle fParamUniform; |
499 SkScalar fPrevRadius; | 493 SkScalar fPrevRadius; |
500 SkScalar fPrevCenterX; | 494 SkScalar fPrevCenterX; |
501 SkScalar fPrevIntervalLength; | 495 SkScalar fPrevIntervalLength; |
502 typedef GrGLGeometryProcessor INHERITED; | 496 typedef GrGLGeometryProcessor INHERITED; |
503 }; | 497 }; |
504 | 498 |
505 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendProcessorFactory& fa
ctory, | 499 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendProcessorFactory& fa
ctory, |
506 const GrProcessor&) | 500 const GrProcessor&) |
507 : INHERITED (factory) { | 501 : INHERITED (factory) { |
508 fPrevRadius = SK_ScalarMin; | 502 fPrevRadius = SK_ScalarMin; |
509 fPrevCenterX = SK_ScalarMin; | 503 fPrevCenterX = SK_ScalarMin; |
510 fPrevIntervalLength = SK_ScalarMax; | 504 fPrevIntervalLength = SK_ScalarMax; |
511 } | 505 } |
512 | 506 |
513 void GLDashingCircleEffect::emitCode(GrGLGPBuilder* builder, | 507 void GLDashingCircleEffect::emitCode(const EmitArgs& args) { |
514 const GrGeometryProcessor& geometryProcessor
, | 508 const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>(); |
515 const GrProcessorKey& key, | |
516 const char* outputColor, | |
517 const char* inputColor, | |
518 const TransformedCoordsArray&, | |
519 const TextureSamplerArray& samplers) { | |
520 const DashingCircleEffect& dce = geometryProcessor.cast<DashingCircleEffect>
(); | |
521 const char *paramName; | 509 const char *paramName; |
522 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and | 510 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and |
523 // the total interval length of the dash. | 511 // the total interval length of the dash. |
524 fParamUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 512 fParamUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibilit
y, |
525 kVec3f_GrSLType, | 513 kVec3f_GrSLType, |
526 "params", | 514 "params", |
527 ¶mName); | 515 ¶mName); |
528 | 516 |
529 const char *vsCoordName, *fsCoordName; | 517 const char *vsCoordName, *fsCoordName; |
530 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); | 518 args.fPB->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); |
531 | 519 |
532 GrGLVertexBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 520 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
533 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, dce.inCoord().c_str()); | 521 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, dce.inCoord().c_str()); |
534 | 522 |
535 // transforms all points so that we can compare them to our test circle | 523 // transforms all points so that we can compare them to our test circle |
536 GrGLGPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 524 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
537 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s.z) * %s.
z;\n", | 525 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s.z) * %s.
z;\n", |
538 fsCoordName, fsCoordName, paramName, paramName); | 526 fsCoordName, fsCoordName, paramName, paramName); |
539 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); | 527 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); |
540 fsBuilder->codeAppendf("\t\tvec2 center = vec2(%s.y, 0.0);\n", paramName); | 528 fsBuilder->codeAppendf("\t\tvec2 center = vec2(%s.y, 0.0);\n", paramName); |
541 fsBuilder->codeAppend("\t\tfloat dist = length(center - fragPosShifted);\n")
; | 529 fsBuilder->codeAppend("\t\tfloat dist = length(center - fragPosShifted);\n")
; |
542 if (GrProcessorEdgeTypeIsAA(dce.getEdgeType())) { | 530 if (GrProcessorEdgeTypeIsAA(dce.getEdgeType())) { |
543 fsBuilder->codeAppendf("\t\tfloat diff = dist - %s.x;\n", paramName); | 531 fsBuilder->codeAppendf("\t\tfloat diff = dist - %s.x;\n", paramName); |
544 fsBuilder->codeAppend("\t\tdiff = 1.0 - diff;\n"); | 532 fsBuilder->codeAppend("\t\tdiff = 1.0 - diff;\n"); |
545 fsBuilder->codeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n"); | 533 fsBuilder->codeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n"); |
546 } else { | 534 } else { |
547 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); | 535 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); |
548 fsBuilder->codeAppendf("\t\talpha *= dist < %s.x + 0.5 ? 1.0 : 0.0;\n",
paramName); | 536 fsBuilder->codeAppendf("\t\talpha *= dist < %s.x + 0.5 ? 1.0 : 0.0;\n",
paramName); |
549 } | 537 } |
550 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, | 538 fsBuilder->codeAppendf("\t\t%s = %s;\n", args.fOutput, |
551 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 539 (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("alpha")).c_s
tr()); |
552 } | 540 } |
553 | 541 |
554 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman | 542 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman |
555 , const GrProcessor& processor) { | 543 , const GrProcessor& processor) { |
556 const DashingCircleEffect& dce = processor.cast<DashingCircleEffect>(); | 544 const DashingCircleEffect& dce = processor.cast<DashingCircleEffect>(); |
557 SkScalar radius = dce.getRadius(); | 545 SkScalar radius = dce.getRadius(); |
558 SkScalar centerX = dce.getCenterX(); | 546 SkScalar centerX = dce.getCenterX(); |
559 SkScalar intervalLength = dce.getIntervalLength(); | 547 SkScalar intervalLength = dce.getIntervalLength(); |
560 if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fP
revIntervalLength) { | 548 if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fP
revIntervalLength) { |
561 pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength); | 549 pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength); |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
686 | 674 |
687 typedef GrGeometryProcessor INHERITED; | 675 typedef GrGeometryProcessor INHERITED; |
688 }; | 676 }; |
689 | 677 |
690 ////////////////////////////////////////////////////////////////////////////// | 678 ////////////////////////////////////////////////////////////////////////////// |
691 | 679 |
692 class GLDashingLineEffect : public GrGLGeometryProcessor { | 680 class GLDashingLineEffect : public GrGLGeometryProcessor { |
693 public: | 681 public: |
694 GLDashingLineEffect(const GrBackendProcessorFactory&, const GrProcessor&); | 682 GLDashingLineEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
695 | 683 |
696 virtual void emitCode(GrGLGPBuilder* builder, | 684 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; |
697 const GrGeometryProcessor& geometryProcessor, | |
698 const GrProcessorKey& key, | |
699 const char* outputColor, | |
700 const char* inputColor, | |
701 const TransformedCoordsArray&, | |
702 const TextureSamplerArray&) SK_OVERRIDE; | |
703 | 685 |
704 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 686 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
705 | 687 |
706 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 688 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
707 | 689 |
708 private: | 690 private: |
709 GrGLProgramDataManager::UniformHandle fRectUniform; | 691 GrGLProgramDataManager::UniformHandle fRectUniform; |
710 GrGLProgramDataManager::UniformHandle fIntervalUniform; | 692 GrGLProgramDataManager::UniformHandle fIntervalUniform; |
711 SkRect fPrevRect; | 693 SkRect fPrevRect; |
712 SkScalar fPrevIntervalLength; | 694 SkScalar fPrevIntervalLength; |
713 typedef GrGLGeometryProcessor INHERITED; | 695 typedef GrGLGeometryProcessor INHERITED; |
714 }; | 696 }; |
715 | 697 |
716 GLDashingLineEffect::GLDashingLineEffect(const GrBackendProcessorFactory& factor
y, | 698 GLDashingLineEffect::GLDashingLineEffect(const GrBackendProcessorFactory& factor
y, |
717 const GrProcessor&) | 699 const GrProcessor&) |
718 : INHERITED (factory) { | 700 : INHERITED (factory) { |
719 fPrevRect.fLeft = SK_ScalarNaN; | 701 fPrevRect.fLeft = SK_ScalarNaN; |
720 fPrevIntervalLength = SK_ScalarMax; | 702 fPrevIntervalLength = SK_ScalarMax; |
721 } | 703 } |
722 | 704 |
723 void GLDashingLineEffect::emitCode(GrGLGPBuilder* builder, | 705 void GLDashingLineEffect::emitCode(const EmitArgs& args) { |
724 const GrGeometryProcessor& geometryProcessor, | 706 const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>(); |
725 const GrProcessorKey& key, | |
726 const char* outputColor, | |
727 const char* inputColor, | |
728 const TransformedCoordsArray&, | |
729 const TextureSamplerArray& samplers) { | |
730 const DashingLineEffect& de = geometryProcessor.cast<DashingLineEffect>(); | |
731 const char *rectName; | 707 const char *rectName; |
732 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), | 708 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), |
733 // respectively. | 709 // respectively. |
734 fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 710 fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
735 kVec4f_GrSLType, | 711 kVec4f_GrSLType, |
736 "rect", | 712 "rect", |
737 &rectName); | 713 &rectName); |
738 const char *intervalName; | 714 const char *intervalName; |
739 // The interval uniform's refers to the total length of the interval (on + o
ff) | 715 // The interval uniform's refers to the total length of the interval (on + o
ff) |
740 fIntervalUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibil
ity, | 716 fIntervalUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibi
lity, |
741 kFloat_GrSLType, | 717 kFloat_GrSLType, |
742 "interval", | 718 "interval", |
743 &intervalName); | 719 &intervalName); |
744 | 720 |
745 const char *vsCoordName, *fsCoordName; | 721 const char *vsCoordName, *fsCoordName; |
746 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); | 722 args.fPB->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); |
747 GrGLVertexBuilder* vsBuilder = builder->getVertexShaderBuilder(); | 723 GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
748 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, de.inCoord().c_str()); | 724 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, de.inCoord().c_str()); |
749 | 725 |
750 // transforms all points so that we can compare them to our test rect | 726 // transforms all points so that we can compare them to our test rect |
751 GrGLGPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 727 GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
752 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s) * %s;\n
", | 728 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s) * %s;\n
", |
753 fsCoordName, fsCoordName, intervalName, intervalName)
; | 729 fsCoordName, fsCoordName, intervalName, intervalName)
; |
754 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); | 730 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); |
755 if (GrProcessorEdgeTypeIsAA(de.getEdgeType())) { | 731 if (GrProcessorEdgeTypeIsAA(de.getEdgeType())) { |
756 // The amount of coverage removed in x and y by the edges is computed as
a pair of negative | 732 // The amount of coverage removed in x and y by the edges is computed as
a pair of negative |
757 // numbers, xSub and ySub. | 733 // numbers, xSub and ySub. |
758 fsBuilder->codeAppend("\t\tfloat xSub, ySub;\n"); | 734 fsBuilder->codeAppend("\t\tfloat xSub, ySub;\n"); |
759 fsBuilder->codeAppendf("\t\txSub = min(fragPosShifted.x - %s.x, 0.0);\n"
, rectName); | 735 fsBuilder->codeAppendf("\t\txSub = min(fragPosShifted.x - %s.x, 0.0);\n"
, rectName); |
760 fsBuilder->codeAppendf("\t\txSub += min(%s.z - fragPosShifted.x, 0.0);\n
", rectName); | 736 fsBuilder->codeAppendf("\t\txSub += min(%s.z - fragPosShifted.x, 0.0);\n
", rectName); |
761 fsBuilder->codeAppendf("\t\tySub = min(fragPosShifted.y - %s.y, 0.0);\n"
, rectName); | 737 fsBuilder->codeAppendf("\t\tySub = min(fragPosShifted.y - %s.y, 0.0);\n"
, rectName); |
762 fsBuilder->codeAppendf("\t\tySub += min(%s.w - fragPosShifted.y, 0.0);\n
", rectName); | 738 fsBuilder->codeAppendf("\t\tySub += min(%s.w - fragPosShifted.y, 0.0);\n
", rectName); |
763 // Now compute coverage in x and y and multiply them to get the fraction
of the pixel | 739 // Now compute coverage in x and y and multiply them to get the fraction
of the pixel |
764 // covered. | 740 // covered. |
765 fsBuilder->codeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0
+ max(ySub, -1.0));\n"); | 741 fsBuilder->codeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0
+ max(ySub, -1.0));\n"); |
766 } else { | 742 } else { |
767 // Assuming the bounding geometry is tight so no need to check y values | 743 // Assuming the bounding geometry is tight so no need to check y values |
768 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); | 744 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); |
769 fsBuilder->codeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ?
1.0 : 0.0;\n", rectName); | 745 fsBuilder->codeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ?
1.0 : 0.0;\n", rectName); |
770 fsBuilder->codeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ?
1.0 : 0.0;\n", rectName); | 746 fsBuilder->codeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ?
1.0 : 0.0;\n", rectName); |
771 } | 747 } |
772 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, | 748 fsBuilder->codeAppendf("\t\t%s = %s;\n", args.fOutput, |
773 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 749 (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("alpha")).c_s
tr()); |
774 } | 750 } |
775 | 751 |
776 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, | 752 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, |
777 const GrProcessor& processor) { | 753 const GrProcessor& processor) { |
778 const DashingLineEffect& de = processor.cast<DashingLineEffect>(); | 754 const DashingLineEffect& de = processor.cast<DashingLineEffect>(); |
779 const SkRect& rect = de.getRect(); | 755 const SkRect& rect = de.getRect(); |
780 SkScalar intervalLength = de.getIntervalLength(); | 756 SkScalar intervalLength = de.getIntervalLength(); |
781 if (rect != fPrevRect || intervalLength != fPrevIntervalLength) { | 757 if (rect != fPrevRect || intervalLength != fPrevIntervalLength) { |
782 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, | 758 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, |
783 rect.fRight - 0.5f, rect.fBottom - 0.5f); | 759 rect.fRight - 0.5f, rect.fBottom - 0.5f); |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
865 switch (cap) { | 841 switch (cap) { |
866 case GrDashingEffect::kRound_DashCap: | 842 case GrDashingEffect::kRound_DashCap: |
867 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); | 843 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); |
868 case GrDashingEffect::kNonRound_DashCap: | 844 case GrDashingEffect::kNonRound_DashCap: |
869 return DashingLineEffect::Create(edgeType, info, strokeWidth); | 845 return DashingLineEffect::Create(edgeType, info, strokeWidth); |
870 default: | 846 default: |
871 SkFAIL("Unexpected dashed cap."); | 847 SkFAIL("Unexpected dashed cap."); |
872 } | 848 } |
873 return NULL; | 849 return NULL; |
874 } | 850 } |
OLD | NEW |