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 "gl/builders/GrGLProgramBuilder.h" |
8 #include "GrDashingEffect.h" | 9 #include "GrDashingEffect.h" |
9 | 10 |
10 #include "../GrAARectRenderer.h" | 11 #include "../GrAARectRenderer.h" |
11 | 12 |
12 #include "effects/GrVertexEffect.h" | 13 #include "effects/GrVertexEffect.h" |
13 #include "gl/GrGLEffect.h" | 14 #include "gl/GrGLEffect.h" |
14 #include "gl/GrGLVertexEffect.h" | 15 #include "gl/GrGLVertexEffect.h" |
15 #include "gl/GrGLShaderBuilder.h" | |
16 #include "gl/GrGLSL.h" | 16 #include "gl/GrGLSL.h" |
17 #include "GrContext.h" | 17 #include "GrContext.h" |
18 #include "GrCoordTransform.h" | 18 #include "GrCoordTransform.h" |
19 #include "GrDrawTarget.h" | 19 #include "GrDrawTarget.h" |
20 #include "GrDrawTargetCaps.h" | 20 #include "GrDrawTargetCaps.h" |
21 #include "GrEffect.h" | 21 #include "GrEffect.h" |
22 #include "GrGpu.h" | 22 #include "GrGpu.h" |
23 #include "GrStrokeInfo.h" | 23 #include "GrStrokeInfo.h" |
24 #include "GrTBackendEffectFactory.h" | 24 #include "GrTBackendEffectFactory.h" |
25 #include "SkGr.h" | 25 #include "SkGr.h" |
(...skipping 435 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
461 | 461 |
462 typedef GrVertexEffect INHERITED; | 462 typedef GrVertexEffect INHERITED; |
463 }; | 463 }; |
464 | 464 |
465 ////////////////////////////////////////////////////////////////////////////// | 465 ////////////////////////////////////////////////////////////////////////////// |
466 | 466 |
467 class GLDashingCircleEffect : public GrGLVertexEffect { | 467 class GLDashingCircleEffect : public GrGLVertexEffect { |
468 public: | 468 public: |
469 GLDashingCircleEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | 469 GLDashingCircleEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
470 | 470 |
471 virtual void emitCode(GrGLFullShaderBuilder* builder, | 471 virtual void emitCode(GrGLFullProgramBuilder* builder, |
472 const GrDrawEffect& drawEffect, | 472 const GrDrawEffect& drawEffect, |
473 const GrEffectKey& key, | 473 const GrEffectKey& key, |
474 const char* outputColor, | 474 const char* outputColor, |
475 const char* inputColor, | 475 const char* inputColor, |
476 const TransformedCoordsArray&, | 476 const TransformedCoordsArray&, |
477 const TextureSamplerArray&) SK_OVERRIDE; | 477 const TextureSamplerArray&) SK_OVERRIDE; |
478 | 478 |
479 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); | 479 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
480 | 480 |
481 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; | 481 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
482 | 482 |
483 private: | 483 private: |
484 GrGLProgramDataManager::UniformHandle fParamUniform; | 484 GrGLProgramDataManager::UniformHandle fParamUniform; |
485 SkScalar fPrevRadius; | 485 SkScalar fPrevRadius; |
486 SkScalar fPrevCenterX; | 486 SkScalar fPrevCenterX; |
487 SkScalar fPrevIntervalLength; | 487 SkScalar fPrevIntervalLength; |
488 typedef GrGLVertexEffect INHERITED; | 488 typedef GrGLVertexEffect INHERITED; |
489 }; | 489 }; |
490 | 490 |
491 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendEffectFactory& facto
ry, | 491 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendEffectFactory& facto
ry, |
492 const GrDrawEffect& drawEffect) | 492 const GrDrawEffect& drawEffect) |
493 : INHERITED (factory) { | 493 : INHERITED (factory) { |
494 fPrevRadius = SK_ScalarMin; | 494 fPrevRadius = SK_ScalarMin; |
495 fPrevCenterX = SK_ScalarMin; | 495 fPrevCenterX = SK_ScalarMin; |
496 fPrevIntervalLength = SK_ScalarMax; | 496 fPrevIntervalLength = SK_ScalarMax; |
497 } | 497 } |
498 | 498 |
499 void GLDashingCircleEffect::emitCode(GrGLFullShaderBuilder* builder, | 499 void GLDashingCircleEffect::emitCode(GrGLFullProgramBuilder* builder, |
500 const GrDrawEffect& drawEffect, | 500 const GrDrawEffect& drawEffect, |
501 const GrEffectKey& key, | 501 const GrEffectKey& key, |
502 const char* outputColor, | 502 const char* outputColor, |
503 const char* inputColor, | 503 const char* inputColor, |
504 const TransformedCoordsArray&, | 504 const TransformedCoordsArray&, |
505 const TextureSamplerArray& samplers) { | 505 const TextureSamplerArray& samplers) { |
506 const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>(
); | 506 const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>(
); |
507 const char *paramName; | 507 const char *paramName; |
508 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and | 508 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and |
509 // the total interval length of the dash. | 509 // the total interval length of the dash. |
510 fParamUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 510 fParamUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
511 kVec3f_GrSLType, | 511 kVec3f_GrSLType, |
512 "params", | 512 "params", |
513 ¶mName); | 513 ¶mName); |
514 | 514 |
515 const char *vsCoordName, *fsCoordName; | 515 const char *vsCoordName, *fsCoordName; |
516 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); | 516 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); |
| 517 |
| 518 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
517 const SkString* attr0Name = | 519 const SkString* attr0Name = |
518 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); | 520 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
519 builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attr0Name->c_str()); | 521 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, attr0Name->c_str()); |
520 | 522 |
521 // 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 |
522 builder->fsCodeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s.z) * %s.
z;\n", | 524 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 525 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s.z) * %s.
z;\n", |
523 fsCoordName, fsCoordName, paramName, paramName); | 526 fsCoordName, fsCoordName, paramName, paramName); |
524 builder->fsCodeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); | 527 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); |
525 builder->fsCodeAppendf("\t\tvec2 center = vec2(%s.y, 0.0);\n", paramName); | 528 fsBuilder->codeAppendf("\t\tvec2 center = vec2(%s.y, 0.0);\n", paramName); |
526 builder->fsCodeAppend("\t\tfloat dist = length(center - fragPosShifted);\n")
; | 529 fsBuilder->codeAppend("\t\tfloat dist = length(center - fragPosShifted);\n")
; |
527 if (GrEffectEdgeTypeIsAA(dce.getEdgeType())) { | 530 if (GrEffectEdgeTypeIsAA(dce.getEdgeType())) { |
528 builder->fsCodeAppendf("\t\tfloat diff = dist - %s.x;\n", paramName); | 531 fsBuilder->codeAppendf("\t\tfloat diff = dist - %s.x;\n", paramName); |
529 builder->fsCodeAppend("\t\tdiff = 1.0 - diff;\n"); | 532 fsBuilder->codeAppend("\t\tdiff = 1.0 - diff;\n"); |
530 builder->fsCodeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n"); | 533 fsBuilder->codeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n"); |
531 } else { | 534 } else { |
532 builder->fsCodeAppendf("\t\tfloat alpha = 1.0;\n"); | 535 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); |
533 builder->fsCodeAppendf("\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); |
534 } | 537 } |
535 builder->fsCodeAppendf("\t\t%s = %s;\n", outputColor, | 538 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, |
536 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 539 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); |
537 } | 540 } |
538 | 541 |
539 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const G
rDrawEffect& drawEffect) { | 542 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const G
rDrawEffect& drawEffect) { |
540 const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>(
); | 543 const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>(
); |
541 SkScalar radius = dce.getRadius(); | 544 SkScalar radius = dce.getRadius(); |
542 SkScalar centerX = dce.getCenterX(); | 545 SkScalar centerX = dce.getCenterX(); |
543 SkScalar intervalLength = dce.getIntervalLength(); | 546 SkScalar intervalLength = dce.getIntervalLength(); |
544 if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fP
revIntervalLength) { | 547 if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fP
revIntervalLength) { |
545 pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength); | 548 pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength); |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
666 | 669 |
667 typedef GrVertexEffect INHERITED; | 670 typedef GrVertexEffect INHERITED; |
668 }; | 671 }; |
669 | 672 |
670 ////////////////////////////////////////////////////////////////////////////// | 673 ////////////////////////////////////////////////////////////////////////////// |
671 | 674 |
672 class GLDashingLineEffect : public GrGLVertexEffect { | 675 class GLDashingLineEffect : public GrGLVertexEffect { |
673 public: | 676 public: |
674 GLDashingLineEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | 677 GLDashingLineEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
675 | 678 |
676 virtual void emitCode(GrGLFullShaderBuilder* builder, | 679 virtual void emitCode(GrGLFullProgramBuilder* builder, |
677 const GrDrawEffect& drawEffect, | 680 const GrDrawEffect& drawEffect, |
678 const GrEffectKey& key, | 681 const GrEffectKey& key, |
679 const char* outputColor, | 682 const char* outputColor, |
680 const char* inputColor, | 683 const char* inputColor, |
681 const TransformedCoordsArray&, | 684 const TransformedCoordsArray&, |
682 const TextureSamplerArray&) SK_OVERRIDE; | 685 const TextureSamplerArray&) SK_OVERRIDE; |
683 | 686 |
684 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); | 687 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
685 | 688 |
686 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; | 689 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
687 | 690 |
688 private: | 691 private: |
689 GrGLProgramDataManager::UniformHandle fRectUniform; | 692 GrGLProgramDataManager::UniformHandle fRectUniform; |
690 GrGLProgramDataManager::UniformHandle fIntervalUniform; | 693 GrGLProgramDataManager::UniformHandle fIntervalUniform; |
691 SkRect fPrevRect; | 694 SkRect fPrevRect; |
692 SkScalar fPrevIntervalLength; | 695 SkScalar fPrevIntervalLength; |
693 typedef GrGLVertexEffect INHERITED; | 696 typedef GrGLVertexEffect INHERITED; |
694 }; | 697 }; |
695 | 698 |
696 GLDashingLineEffect::GLDashingLineEffect(const GrBackendEffectFactory& factory, | 699 GLDashingLineEffect::GLDashingLineEffect(const GrBackendEffectFactory& factory, |
697 const GrDrawEffect& drawEffect) | 700 const GrDrawEffect& drawEffect) |
698 : INHERITED (factory) { | 701 : INHERITED (factory) { |
699 fPrevRect.fLeft = SK_ScalarNaN; | 702 fPrevRect.fLeft = SK_ScalarNaN; |
700 fPrevIntervalLength = SK_ScalarMax; | 703 fPrevIntervalLength = SK_ScalarMax; |
701 } | 704 } |
702 | 705 |
703 void GLDashingLineEffect::emitCode(GrGLFullShaderBuilder* builder, | 706 void GLDashingLineEffect::emitCode(GrGLFullProgramBuilder* builder, |
704 const GrDrawEffect& drawEffect, | 707 const GrDrawEffect& drawEffect, |
705 const GrEffectKey& key, | 708 const GrEffectKey& key, |
706 const char* outputColor, | 709 const char* outputColor, |
707 const char* inputColor, | 710 const char* inputColor, |
708 const TransformedCoordsArray&, | 711 const TransformedCoordsArray&, |
709 const TextureSamplerArray& samplers) { | 712 const TextureSamplerArray& samplers) { |
710 const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>(); | 713 const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>(); |
711 const char *rectName; | 714 const char *rectName; |
712 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), | 715 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), |
713 // respectively. | 716 // respectively. |
714 fRectUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 717 fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
715 kVec4f_GrSLType, | 718 kVec4f_GrSLType, |
716 "rect", | 719 "rect", |
717 &rectName); | 720 &rectName); |
718 const char *intervalName; | 721 const char *intervalName; |
719 // The interval uniform's refers to the total length of the interval (on + o
ff) | 722 // The interval uniform's refers to the total length of the interval (on + o
ff) |
720 fIntervalUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibili
ty, | 723 fIntervalUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibil
ity, |
721 kFloat_GrSLType, | 724 kFloat_GrSLType, |
722 "interval", | 725 "interval", |
723 &intervalName); | 726 &intervalName); |
724 | 727 |
725 const char *vsCoordName, *fsCoordName; | 728 const char *vsCoordName, *fsCoordName; |
726 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); | 729 builder->addVarying(kVec2f_GrSLType, "Coord", &vsCoordName, &fsCoordName); |
| 730 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); |
727 const SkString* attr0Name = | 731 const SkString* attr0Name = |
728 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); | 732 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]
); |
729 builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attr0Name->c_str()); | 733 vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, attr0Name->c_str()); |
730 | 734 |
731 // transforms all points so that we can compare them to our test rect | 735 // transforms all points so that we can compare them to our test rect |
732 builder->fsCodeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s) * %s;\n
", | 736 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 737 fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s) * %s;\n
", |
733 fsCoordName, fsCoordName, intervalName, intervalName)
; | 738 fsCoordName, fsCoordName, intervalName, intervalName)
; |
734 builder->fsCodeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); | 739 fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n",
fsCoordName); |
735 if (GrEffectEdgeTypeIsAA(de.getEdgeType())) { | 740 if (GrEffectEdgeTypeIsAA(de.getEdgeType())) { |
736 // The amount of coverage removed in x and y by the edges is computed as
a pair of negative | 741 // The amount of coverage removed in x and y by the edges is computed as
a pair of negative |
737 // numbers, xSub and ySub. | 742 // numbers, xSub and ySub. |
738 builder->fsCodeAppend("\t\tfloat xSub, ySub;\n"); | 743 fsBuilder->codeAppend("\t\tfloat xSub, ySub;\n"); |
739 builder->fsCodeAppendf("\t\txSub = min(fragPosShifted.x - %s.x, 0.0);\n"
, rectName); | 744 fsBuilder->codeAppendf("\t\txSub = min(fragPosShifted.x - %s.x, 0.0);\n"
, rectName); |
740 builder->fsCodeAppendf("\t\txSub += min(%s.z - fragPosShifted.x, 0.0);\n
", rectName); | 745 fsBuilder->codeAppendf("\t\txSub += min(%s.z - fragPosShifted.x, 0.0);\n
", rectName); |
741 builder->fsCodeAppendf("\t\tySub = min(fragPosShifted.y - %s.y, 0.0);\n"
, rectName); | 746 fsBuilder->codeAppendf("\t\tySub = min(fragPosShifted.y - %s.y, 0.0);\n"
, rectName); |
742 builder->fsCodeAppendf("\t\tySub += min(%s.w - fragPosShifted.y, 0.0);\n
", rectName); | 747 fsBuilder->codeAppendf("\t\tySub += min(%s.w - fragPosShifted.y, 0.0);\n
", rectName); |
743 // Now compute coverage in x and y and multiply them to get the fraction
of the pixel | 748 // Now compute coverage in x and y and multiply them to get the fraction
of the pixel |
744 // covered. | 749 // covered. |
745 builder->fsCodeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0
+ max(ySub, -1.0));\n"); | 750 fsBuilder->codeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0
+ max(ySub, -1.0));\n"); |
746 } else { | 751 } else { |
747 // Assuming the bounding geometry is tight so no need to check y values | 752 // Assuming the bounding geometry is tight so no need to check y values |
748 builder->fsCodeAppendf("\t\tfloat alpha = 1.0;\n"); | 753 fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n"); |
749 builder->fsCodeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ?
1.0 : 0.0;\n", rectName); | 754 fsBuilder->codeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ?
1.0 : 0.0;\n", rectName); |
750 builder->fsCodeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ?
1.0 : 0.0;\n", rectName); | 755 fsBuilder->codeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ?
1.0 : 0.0;\n", rectName); |
751 } | 756 } |
752 builder->fsCodeAppendf("\t\t%s = %s;\n", outputColor, | 757 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, |
753 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 758 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); |
754 } | 759 } |
755 | 760 |
756 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrD
rawEffect& drawEffect) { | 761 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrD
rawEffect& drawEffect) { |
757 const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>(); | 762 const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>(); |
758 const SkRect& rect = de.getRect(); | 763 const SkRect& rect = de.getRect(); |
759 SkScalar intervalLength = de.getIntervalLength(); | 764 SkScalar intervalLength = de.getIntervalLength(); |
760 if (rect != fPrevRect || intervalLength != fPrevIntervalLength) { | 765 if (rect != fPrevRect || intervalLength != fPrevIntervalLength) { |
761 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, | 766 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, |
762 rect.fRight - 0.5f, rect.fBottom - 0.5f); | 767 rect.fRight - 0.5f, rect.fBottom - 0.5f); |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
842 switch (cap) { | 847 switch (cap) { |
843 case GrDashingEffect::kRound_DashCap: | 848 case GrDashingEffect::kRound_DashCap: |
844 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); | 849 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); |
845 case GrDashingEffect::kNonRound_DashCap: | 850 case GrDashingEffect::kNonRound_DashCap: |
846 return DashingLineEffect::Create(edgeType, info, strokeWidth); | 851 return DashingLineEffect::Create(edgeType, info, strokeWidth); |
847 default: | 852 default: |
848 SkFAIL("Unexpected dashed cap."); | 853 SkFAIL("Unexpected dashed cap."); |
849 } | 854 } |
850 return NULL; | 855 return NULL; |
851 } | 856 } |
OLD | NEW |