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" |
11 | 11 |
12 #include "GrGeometryProcessor.h" | 12 #include "GrGeometryProcessor.h" |
13 #include "GrContext.h" | 13 #include "GrContext.h" |
14 #include "GrCoordTransform.h" | 14 #include "GrCoordTransform.h" |
15 #include "GrDefaultGeoProcFactory.h" | 15 #include "GrDefaultGeoProcFactory.h" |
16 #include "GrDrawTarget.h" | 16 #include "GrDrawTarget.h" |
17 #include "GrDrawTargetCaps.h" | 17 #include "GrDrawTargetCaps.h" |
18 #include "GrInvariantOutput.h" | 18 #include "GrInvariantOutput.h" |
19 #include "GrProcessor.h" | 19 #include "GrProcessor.h" |
20 #include "GrStrokeInfo.h" | 20 #include "GrStrokeInfo.h" |
21 #include "GrTBackendProcessorFactory.h" | |
22 #include "SkGr.h" | 21 #include "SkGr.h" |
23 #include "gl/GrGLGeometryProcessor.h" | 22 #include "gl/GrGLGeometryProcessor.h" |
24 #include "gl/GrGLProcessor.h" | 23 #include "gl/GrGLProcessor.h" |
25 #include "gl/GrGLSL.h" | 24 #include "gl/GrGLSL.h" |
26 #include "gl/builders/GrGLProgramBuilder.h" | 25 #include "gl/builders/GrGLProgramBuilder.h" |
27 | 26 |
28 /////////////////////////////////////////////////////////////////////////////// | 27 /////////////////////////////////////////////////////////////////////////////// |
29 | 28 |
30 // Returns whether or not the gpu can fast path the dash line effect. | 29 // Returns whether or not the gpu can fast path the dash line effect. |
31 static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeI
nfo, | 30 static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeI
nfo, |
(...skipping 424 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
456 class DashingCircleEffect : public GrGeometryProcessor { | 455 class DashingCircleEffect : public GrGeometryProcessor { |
457 public: | 456 public: |
458 typedef SkPathEffect::DashInfo DashInfo; | 457 typedef SkPathEffect::DashInfo DashInfo; |
459 | 458 |
460 static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType, | 459 static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType, |
461 const DashInfo& info, | 460 const DashInfo& info, |
462 SkScalar radius); | 461 SkScalar radius); |
463 | 462 |
464 virtual ~DashingCircleEffect(); | 463 virtual ~DashingCircleEffect(); |
465 | 464 |
466 static const char* Name() { return "DashingCircleEffect"; } | 465 virtual const char* name() const SK_OVERRIDE { return "DashingCircleEffect";
} |
467 | 466 |
468 const GrAttribute* inPosition() const { return fInPosition; } | 467 const GrAttribute* inPosition() const { return fInPosition; } |
469 | 468 |
470 const GrAttribute* inCoord() const { return fInCoord; } | 469 const GrAttribute* inCoord() const { return fInCoord; } |
471 | 470 |
472 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 471 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
473 | 472 |
474 SkScalar getRadius() const { return fRadius; } | 473 SkScalar getRadius() const { return fRadius; } |
475 | 474 |
476 SkScalar getCenterX() const { return fCenterX; } | 475 SkScalar getCenterX() const { return fCenterX; } |
477 | 476 |
478 SkScalar getIntervalLength() const { return fIntervalLength; } | 477 SkScalar getIntervalLength() const { return fIntervalLength; } |
479 | 478 |
480 typedef GLDashingCircleEffect GLProcessor; | 479 virtual void getGLProcessorKey(const GrBatchTracker&, |
| 480 const GrGLCaps&, |
| 481 GrProcessorKeyBuilder* b) const SK_OVERRIDE; |
481 | 482 |
482 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE; | 483 virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker&) const
SK_OVERRIDE; |
483 | 484 |
484 private: | 485 private: |
485 DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkSc
alar radius); | 486 DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkSc
alar radius); |
486 | 487 |
487 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE; | 488 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE; |
488 | 489 |
489 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 490 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
490 | 491 |
491 GrPrimitiveEdgeType fEdgeType; | 492 GrPrimitiveEdgeType fEdgeType; |
492 const GrAttribute* fInPosition; | 493 const GrAttribute* fInPosition; |
493 const GrAttribute* fInCoord; | 494 const GrAttribute* fInCoord; |
494 SkScalar fIntervalLength; | 495 SkScalar fIntervalLength; |
495 SkScalar fRadius; | 496 SkScalar fRadius; |
496 SkScalar fCenterX; | 497 SkScalar fCenterX; |
497 | 498 |
498 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 499 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
499 | 500 |
500 typedef GrGeometryProcessor INHERITED; | 501 typedef GrGeometryProcessor INHERITED; |
501 }; | 502 }; |
502 | 503 |
503 ////////////////////////////////////////////////////////////////////////////// | 504 ////////////////////////////////////////////////////////////////////////////// |
504 | 505 |
505 class GLDashingCircleEffect : public GrGLGeometryProcessor { | 506 class GLDashingCircleEffect : public GrGLGeometryProcessor { |
506 public: | 507 public: |
507 GLDashingCircleEffect(const GrBackendProcessorFactory&, | 508 GLDashingCircleEffect(const GrGeometryProcessor&, const GrBatchTracker&); |
508 const GrGeometryProcessor&, | |
509 const GrBatchTracker&); | |
510 | 509 |
511 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; | 510 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; |
512 | 511 |
513 static inline void GenKey(const GrGeometryProcessor&, | 512 static inline void GenKey(const GrGeometryProcessor&, |
514 const GrBatchTracker&, | 513 const GrBatchTracker&, |
515 const GrGLCaps&, | 514 const GrGLCaps&, |
516 GrProcessorKeyBuilder*); | 515 GrProcessorKeyBuilder*); |
517 | 516 |
518 virtual void setData(const GrGLProgramDataManager&, | 517 virtual void setData(const GrGLProgramDataManager&, |
519 const GrGeometryProcessor&, | 518 const GrGeometryProcessor&, |
520 const GrBatchTracker&) SK_OVERRIDE; | 519 const GrBatchTracker&) SK_OVERRIDE; |
521 | 520 |
522 private: | 521 private: |
523 GrGLProgramDataManager::UniformHandle fParamUniform; | 522 GrGLProgramDataManager::UniformHandle fParamUniform; |
524 SkScalar fPrevRadius; | 523 SkScalar fPrevRadius; |
525 SkScalar fPrevCenterX; | 524 SkScalar fPrevCenterX; |
526 SkScalar fPrevIntervalLength; | 525 SkScalar fPrevIntervalLength; |
527 typedef GrGLGeometryProcessor INHERITED; | 526 typedef GrGLGeometryProcessor INHERITED; |
528 }; | 527 }; |
529 | 528 |
530 GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendProcessorFactory& fa
ctory, | 529 GLDashingCircleEffect::GLDashingCircleEffect(const GrGeometryProcessor&, |
531 const GrGeometryProcessor&, | 530 const GrBatchTracker&) { |
532 const GrBatchTracker&) | |
533 : INHERITED (factory) { | |
534 fPrevRadius = SK_ScalarMin; | 531 fPrevRadius = SK_ScalarMin; |
535 fPrevCenterX = SK_ScalarMin; | 532 fPrevCenterX = SK_ScalarMin; |
536 fPrevIntervalLength = SK_ScalarMax; | 533 fPrevIntervalLength = SK_ScalarMax; |
537 } | 534 } |
538 | 535 |
539 void GLDashingCircleEffect::emitCode(const EmitArgs& args) { | 536 void GLDashingCircleEffect::emitCode(const EmitArgs& args) { |
540 const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>(); | 537 const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>(); |
541 const char *paramName; | 538 const char *paramName; |
542 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and | 539 // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x co
ord, and |
543 // the total interval length of the dash. | 540 // the total interval length of the dash. |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
611 | 608 |
612 return SkNEW_ARGS(DashingCircleEffect, (edgeType, info, radius)); | 609 return SkNEW_ARGS(DashingCircleEffect, (edgeType, info, radius)); |
613 } | 610 } |
614 | 611 |
615 DashingCircleEffect::~DashingCircleEffect() {} | 612 DashingCircleEffect::~DashingCircleEffect() {} |
616 | 613 |
617 void DashingCircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
st { | 614 void DashingCircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
st { |
618 inout->mulByUnknownAlpha(); | 615 inout->mulByUnknownAlpha(); |
619 } | 616 } |
620 | 617 |
621 const GrBackendGeometryProcessorFactory& DashingCircleEffect::getFactory() const
{ | 618 void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt, |
622 return GrTBackendGeometryProcessorFactory<DashingCircleEffect>::getInstance(
); | 619 const GrGLCaps& caps, |
| 620 GrProcessorKeyBuilder* b) const { |
| 621 GLDashingCircleEffect::GenKey(*this, bt, caps, b); |
| 622 } |
| 623 |
| 624 GrGLGeometryProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracke
r& bt) const { |
| 625 return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt)); |
623 } | 626 } |
624 | 627 |
625 DashingCircleEffect::DashingCircleEffect(GrPrimitiveEdgeType edgeType, const Das
hInfo& info, | 628 DashingCircleEffect::DashingCircleEffect(GrPrimitiveEdgeType edgeType, const Das
hInfo& info, |
626 SkScalar radius) | 629 SkScalar radius) |
627 : fEdgeType(edgeType) { | 630 : fEdgeType(edgeType) { |
| 631 this->initClassID<DashingCircleEffect>(); |
628 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVert
exAttribType)); | 632 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVert
exAttribType)); |
629 fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttr
ibType)); | 633 fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttr
ibType)); |
630 SkScalar onLen = info.fIntervals[0]; | 634 SkScalar onLen = info.fIntervals[0]; |
631 SkScalar offLen = info.fIntervals[1]; | 635 SkScalar offLen = info.fIntervals[1]; |
632 fIntervalLength = onLen + offLen; | 636 fIntervalLength = onLen + offLen; |
633 fRadius = radius; | 637 fRadius = radius; |
634 fCenterX = SkScalarHalf(offLen); | 638 fCenterX = SkScalarHalf(offLen); |
635 } | 639 } |
636 | 640 |
637 bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const { | 641 bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
678 class DashingLineEffect : public GrGeometryProcessor { | 682 class DashingLineEffect : public GrGeometryProcessor { |
679 public: | 683 public: |
680 typedef SkPathEffect::DashInfo DashInfo; | 684 typedef SkPathEffect::DashInfo DashInfo; |
681 | 685 |
682 static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType, | 686 static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType, |
683 const DashInfo& info, | 687 const DashInfo& info, |
684 SkScalar strokeWidth); | 688 SkScalar strokeWidth); |
685 | 689 |
686 virtual ~DashingLineEffect(); | 690 virtual ~DashingLineEffect(); |
687 | 691 |
688 static const char* Name() { return "DashingEffect"; } | 692 virtual const char* name() const SK_OVERRIDE { return "DashingEffect"; } |
689 | 693 |
690 const GrAttribute* inPosition() const { return fInPosition; } | 694 const GrAttribute* inPosition() const { return fInPosition; } |
691 | 695 |
692 const GrAttribute* inCoord() const { return fInCoord; } | 696 const GrAttribute* inCoord() const { return fInCoord; } |
693 | 697 |
694 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 698 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
695 | 699 |
696 const SkRect& getRect() const { return fRect; } | 700 const SkRect& getRect() const { return fRect; } |
697 | 701 |
698 SkScalar getIntervalLength() const { return fIntervalLength; } | 702 SkScalar getIntervalLength() const { return fIntervalLength; } |
699 | 703 |
700 typedef GLDashingLineEffect GLProcessor; | 704 virtual void getGLProcessorKey(const GrBatchTracker& bt, |
| 705 const GrGLCaps& caps, |
| 706 GrProcessorKeyBuilder* b) const SK_OVERRIDE; |
701 | 707 |
702 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE; | 708 virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) co
nst SK_OVERRIDE; |
703 | 709 |
704 private: | 710 private: |
705 DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScal
ar strokeWidth); | 711 DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScal
ar strokeWidth); |
706 | 712 |
707 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE; | 713 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE; |
708 | 714 |
709 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 715 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
710 | 716 |
711 GrPrimitiveEdgeType fEdgeType; | 717 GrPrimitiveEdgeType fEdgeType; |
712 const GrAttribute* fInPosition; | 718 const GrAttribute* fInPosition; |
713 const GrAttribute* fInCoord; | 719 const GrAttribute* fInCoord; |
714 SkRect fRect; | 720 SkRect fRect; |
715 SkScalar fIntervalLength; | 721 SkScalar fIntervalLength; |
716 | 722 |
717 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 723 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
718 | 724 |
719 typedef GrGeometryProcessor INHERITED; | 725 typedef GrGeometryProcessor INHERITED; |
720 }; | 726 }; |
721 | 727 |
722 ////////////////////////////////////////////////////////////////////////////// | 728 ////////////////////////////////////////////////////////////////////////////// |
723 | 729 |
724 class GLDashingLineEffect : public GrGLGeometryProcessor { | 730 class GLDashingLineEffect : public GrGLGeometryProcessor { |
725 public: | 731 public: |
726 GLDashingLineEffect(const GrBackendProcessorFactory&, | 732 GLDashingLineEffect(const GrGeometryProcessor&, const GrBatchTracker&); |
727 const GrGeometryProcessor&, | |
728 const GrBatchTracker&); | |
729 | 733 |
730 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; | 734 virtual void emitCode(const EmitArgs&) SK_OVERRIDE; |
731 | 735 |
732 static inline void GenKey(const GrGeometryProcessor&, | 736 static inline void GenKey(const GrGeometryProcessor&, |
733 const GrBatchTracker&, | 737 const GrBatchTracker&, |
734 const GrGLCaps&, | 738 const GrGLCaps&, |
735 GrProcessorKeyBuilder*); | 739 GrProcessorKeyBuilder*); |
736 | 740 |
737 virtual void setData(const GrGLProgramDataManager&, | 741 virtual void setData(const GrGLProgramDataManager&, |
738 const GrGeometryProcessor&, | 742 const GrGeometryProcessor&, |
739 const GrBatchTracker&) SK_OVERRIDE; | 743 const GrBatchTracker&) SK_OVERRIDE; |
740 | 744 |
741 private: | 745 private: |
742 GrGLProgramDataManager::UniformHandle fRectUniform; | 746 GrGLProgramDataManager::UniformHandle fRectUniform; |
743 GrGLProgramDataManager::UniformHandle fIntervalUniform; | 747 GrGLProgramDataManager::UniformHandle fIntervalUniform; |
744 SkRect fPrevRect; | 748 SkRect fPrevRect; |
745 SkScalar fPrevIntervalLength; | 749 SkScalar fPrevIntervalLength; |
746 typedef GrGLGeometryProcessor INHERITED; | 750 typedef GrGLGeometryProcessor INHERITED; |
747 }; | 751 }; |
748 | 752 |
749 GLDashingLineEffect::GLDashingLineEffect(const GrBackendProcessorFactory& factor
y, | 753 GLDashingLineEffect::GLDashingLineEffect(const GrGeometryProcessor&, |
750 const GrGeometryProcessor&, | 754 const GrBatchTracker&) { |
751 const GrBatchTracker&) | |
752 : INHERITED (factory) { | |
753 fPrevRect.fLeft = SK_ScalarNaN; | 755 fPrevRect.fLeft = SK_ScalarNaN; |
754 fPrevIntervalLength = SK_ScalarMax; | 756 fPrevIntervalLength = SK_ScalarMax; |
755 } | 757 } |
756 | 758 |
757 void GLDashingLineEffect::emitCode(const EmitArgs& args) { | 759 void GLDashingLineEffect::emitCode(const EmitArgs& args) { |
758 const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>(); | 760 const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>(); |
759 const char *rectName; | 761 const char *rectName; |
760 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), | 762 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), |
761 // respectively. | 763 // respectively. |
762 fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 764 fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
844 | 846 |
845 return SkNEW_ARGS(DashingLineEffect, (edgeType, info, strokeWidth)); | 847 return SkNEW_ARGS(DashingLineEffect, (edgeType, info, strokeWidth)); |
846 } | 848 } |
847 | 849 |
848 DashingLineEffect::~DashingLineEffect() {} | 850 DashingLineEffect::~DashingLineEffect() {} |
849 | 851 |
850 void DashingLineEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
{ | 852 void DashingLineEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
{ |
851 inout->mulByUnknownAlpha(); | 853 inout->mulByUnknownAlpha(); |
852 } | 854 } |
853 | 855 |
854 const GrBackendGeometryProcessorFactory& DashingLineEffect::getFactory() const { | 856 void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt, |
855 return GrTBackendGeometryProcessorFactory<DashingLineEffect>::getInstance(); | 857 const GrGLCaps& caps, |
| 858 GrProcessorKeyBuilder* b) const { |
| 859 GLDashingLineEffect::GenKey(*this, bt, caps, b); |
| 860 } |
| 861 |
| 862 GrGLGeometryProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker&
bt) const { |
| 863 return SkNEW_ARGS(GLDashingLineEffect, (*this, bt)); |
856 } | 864 } |
857 | 865 |
858 DashingLineEffect::DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInf
o& info, | 866 DashingLineEffect::DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInf
o& info, |
859 SkScalar strokeWidth) | 867 SkScalar strokeWidth) |
860 : fEdgeType(edgeType) { | 868 : fEdgeType(edgeType) { |
| 869 this->initClassID<DashingLineEffect>(); |
861 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVert
exAttribType)); | 870 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVert
exAttribType)); |
862 fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttr
ibType)); | 871 fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttr
ibType)); |
863 SkScalar onLen = info.fIntervals[0]; | 872 SkScalar onLen = info.fIntervals[0]; |
864 SkScalar offLen = info.fIntervals[1]; | 873 SkScalar offLen = info.fIntervals[1]; |
865 SkScalar halfOffLen = SkScalarHalf(offLen); | 874 SkScalar halfOffLen = SkScalarHalf(offLen); |
866 SkScalar halfStroke = SkScalarHalf(strokeWidth); | 875 SkScalar halfStroke = SkScalarHalf(strokeWidth); |
867 fIntervalLength = onLen + offLen; | 876 fIntervalLength = onLen + offLen; |
868 fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke); | 877 fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke); |
869 } | 878 } |
870 | 879 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
904 switch (cap) { | 913 switch (cap) { |
905 case GrDashingEffect::kRound_DashCap: | 914 case GrDashingEffect::kRound_DashCap: |
906 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); | 915 return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(stro
keWidth)); |
907 case GrDashingEffect::kNonRound_DashCap: | 916 case GrDashingEffect::kNonRound_DashCap: |
908 return DashingLineEffect::Create(edgeType, info, strokeWidth); | 917 return DashingLineEffect::Create(edgeType, info, strokeWidth); |
909 default: | 918 default: |
910 SkFAIL("Unexpected dashed cap."); | 919 SkFAIL("Unexpected dashed cap."); |
911 } | 920 } |
912 return NULL; | 921 return NULL; |
913 } | 922 } |
OLD | NEW |