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" | |
9 #include "GrRRectEffect.h" | 8 #include "GrRRectEffect.h" |
10 | 9 |
| 10 #include "GrConvexPolyEffect.h" |
| 11 #include "GrFragmentProcessor.h" |
| 12 #include "GrInvariantOutput.h" |
| 13 #include "GrOvalEffect.h" |
| 14 #include "SkRRect.h" |
11 #include "gl/GrGLProcessor.h" | 15 #include "gl/GrGLProcessor.h" |
12 #include "gl/GrGLSL.h" | 16 #include "gl/GrGLSL.h" |
13 #include "GrConvexPolyEffect.h" | 17 #include "gl/builders/GrGLProgramBuilder.h" |
14 #include "GrInvariantOutput.h" | |
15 #include "GrOvalEffect.h" | |
16 #include "GrTBackendProcessorFactory.h" | |
17 | |
18 #include "SkRRect.h" | |
19 | 18 |
20 // The effects defined here only handle rrect radii >= kRadiusMin. | 19 // The effects defined here only handle rrect radii >= kRadiusMin. |
21 static const SkScalar kRadiusMin = SK_ScalarHalf; | 20 static const SkScalar kRadiusMin = SK_ScalarHalf; |
22 | 21 |
23 ////////////////////////////////////////////////////////////////////////////// | 22 ////////////////////////////////////////////////////////////////////////////// |
24 | 23 |
25 class GLCircularRRectEffect; | |
26 | |
27 class CircularRRectEffect : public GrFragmentProcessor { | 24 class CircularRRectEffect : public GrFragmentProcessor { |
28 public: | 25 public: |
29 | 26 |
30 enum CornerFlags { | 27 enum CornerFlags { |
31 kTopLeft_CornerFlag = (1 << SkRRect::kUpperLeft_Corner), | 28 kTopLeft_CornerFlag = (1 << SkRRect::kUpperLeft_Corner), |
32 kTopRight_CornerFlag = (1 << SkRRect::kUpperRight_Corner), | 29 kTopRight_CornerFlag = (1 << SkRRect::kUpperRight_Corner), |
33 kBottomRight_CornerFlag = (1 << SkRRect::kLowerRight_Corner), | 30 kBottomRight_CornerFlag = (1 << SkRRect::kLowerRight_Corner), |
34 kBottomLeft_CornerFlag = (1 << SkRRect::kLowerLeft_Corner), | 31 kBottomLeft_CornerFlag = (1 << SkRRect::kLowerLeft_Corner), |
35 | 32 |
36 kLeft_CornerFlags = kTopLeft_CornerFlag | kBottomLeft_CornerFlag, | 33 kLeft_CornerFlags = kTopLeft_CornerFlag | kBottomLeft_CornerFlag, |
37 kTop_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag, | 34 kTop_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag, |
38 kRight_CornerFlags = kTopRight_CornerFlag | kBottomRight_CornerFlag, | 35 kRight_CornerFlags = kTopRight_CornerFlag | kBottomRight_CornerFlag, |
39 kBottom_CornerFlags = kBottomLeft_CornerFlag | kBottomRight_CornerFlag, | 36 kBottom_CornerFlags = kBottomLeft_CornerFlag | kBottomRight_CornerFlag, |
40 | 37 |
41 kAll_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag | | 38 kAll_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag | |
42 kBottomLeft_CornerFlag | kBottomRight_CornerFlag, | 39 kBottomLeft_CornerFlag | kBottomRight_CornerFlag, |
43 | 40 |
44 kNone_CornerFlags = 0 | 41 kNone_CornerFlags = 0 |
45 }; | 42 }; |
46 | 43 |
47 // The flags are used to indicate which corners are circluar (unflagged corn
ers are assumed to | 44 // The flags are used to indicate which corners are circluar (unflagged corn
ers are assumed to |
48 // be square). | 45 // be square). |
49 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, uint32_t circularCor
nerFlags, | 46 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, uint32_t circularCor
nerFlags, |
50 const SkRRect&); | 47 const SkRRect&); |
51 | 48 |
52 virtual ~CircularRRectEffect() {}; | 49 virtual ~CircularRRectEffect() {}; |
53 static const char* Name() { return "CircularRRect"; } | 50 |
| 51 virtual const char* name() const SK_OVERRIDE { return "CircularRRect"; } |
| 52 |
| 53 virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) cons
t SK_OVERRIDE; |
| 54 |
| 55 virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE; |
54 | 56 |
55 const SkRRect& getRRect() const { return fRRect; } | 57 const SkRRect& getRRect() const { return fRRect; } |
56 | 58 |
57 uint32_t getCircularCornerFlags() const { return fCircularCornerFlags; } | 59 uint32_t getCircularCornerFlags() const { return fCircularCornerFlags; } |
58 | 60 |
59 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 61 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
60 | 62 |
61 typedef GLCircularRRectEffect GLProcessor; | |
62 | |
63 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; | |
64 | |
65 private: | 63 private: |
66 CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const
SkRRect&); | 64 CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const
SkRRect&); |
67 | 65 |
68 virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE; | 66 virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE; |
69 | 67 |
70 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 68 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
71 | 69 |
72 SkRRect fRRect; | 70 SkRRect fRRect; |
73 GrPrimitiveEdgeType fEdgeType; | 71 GrPrimitiveEdgeType fEdgeType; |
74 uint32_t fCircularCornerFlags; | 72 uint32_t fCircularCornerFlags; |
75 | 73 |
76 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 74 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
77 | 75 |
78 typedef GrFragmentProcessor INHERITED; | 76 typedef GrFragmentProcessor INHERITED; |
79 }; | 77 }; |
80 | 78 |
81 GrFragmentProcessor* CircularRRectEffect::Create(GrPrimitiveEdgeType edgeType, | 79 GrFragmentProcessor* CircularRRectEffect::Create(GrPrimitiveEdgeType edgeType, |
82 uint32_t circularCornerFlags, | 80 uint32_t circularCornerFlags, |
83 const SkRRect& rrect) { | 81 const SkRRect& rrect) { |
84 if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdg
eType != edgeType) { | 82 if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdg
eType != edgeType) { |
85 return NULL; | 83 return NULL; |
86 } | 84 } |
87 return SkNEW_ARGS(CircularRRectEffect, (edgeType, circularCornerFlags, rrect
)); | 85 return SkNEW_ARGS(CircularRRectEffect, (edgeType, circularCornerFlags, rrect
)); |
88 } | 86 } |
89 | 87 |
90 void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
st { | 88 void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
st { |
91 inout->mulByUnknownAlpha(); | 89 inout->mulByUnknownAlpha(); |
92 } | 90 } |
93 | 91 |
94 const GrBackendFragmentProcessorFactory& CircularRRectEffect::getFactory() const
{ | |
95 return GrTBackendFragmentProcessorFactory<CircularRRectEffect>::getInstance(
); | |
96 } | |
97 | |
98 CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t
circularCornerFlags, | 92 CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t
circularCornerFlags, |
99 const SkRRect& rrect) | 93 const SkRRect& rrect) |
100 : fRRect(rrect) | 94 : fRRect(rrect) |
101 , fEdgeType(edgeType) | 95 , fEdgeType(edgeType) |
102 , fCircularCornerFlags(circularCornerFlags) { | 96 , fCircularCornerFlags(circularCornerFlags) { |
| 97 this->initClassID<CircularRRectEffect>(); |
103 this->setWillReadFragmentPosition(); | 98 this->setWillReadFragmentPosition(); |
104 } | 99 } |
105 | 100 |
106 bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { | 101 bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { |
107 const CircularRRectEffect& crre = other.cast<CircularRRectEffect>(); | 102 const CircularRRectEffect& crre = other.cast<CircularRRectEffect>(); |
108 // The corner flags are derived from fRRect, so no need to check them. | 103 // The corner flags are derived from fRRect, so no need to check them. |
109 return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect; | 104 return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect; |
110 } | 105 } |
111 | 106 |
112 ////////////////////////////////////////////////////////////////////////////// | 107 ////////////////////////////////////////////////////////////////////////////// |
(...skipping 15 matching lines...) Expand all Loading... |
128 (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeC
nt); | 123 (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeC
nt); |
129 fp = GrRRectEffect::Create(et, rrect); | 124 fp = GrRRectEffect::Create(et, rrect); |
130 } while (NULL == fp); | 125 } while (NULL == fp); |
131 return fp; | 126 return fp; |
132 } | 127 } |
133 | 128 |
134 ////////////////////////////////////////////////////////////////////////////// | 129 ////////////////////////////////////////////////////////////////////////////// |
135 | 130 |
136 class GLCircularRRectEffect : public GrGLFragmentProcessor { | 131 class GLCircularRRectEffect : public GrGLFragmentProcessor { |
137 public: | 132 public: |
138 GLCircularRRectEffect(const GrBackendProcessorFactory&, const GrProcessor&); | 133 GLCircularRRectEffect(const GrProcessor&); |
139 | 134 |
140 virtual void emitCode(GrGLFPBuilder* builder, | 135 virtual void emitCode(GrGLFPBuilder* builder, |
141 const GrFragmentProcessor& fp, | 136 const GrFragmentProcessor& fp, |
142 const char* outputColor, | 137 const char* outputColor, |
143 const char* inputColor, | 138 const char* inputColor, |
144 const TransformedCoordsArray&, | 139 const TransformedCoordsArray&, |
145 const TextureSamplerArray&) SK_OVERRIDE; | 140 const TextureSamplerArray&) SK_OVERRIDE; |
146 | 141 |
147 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 142 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
148 | 143 |
149 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 144 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
150 | 145 |
151 private: | 146 private: |
152 GrGLProgramDataManager::UniformHandle fInnerRectUniform; | 147 GrGLProgramDataManager::UniformHandle fInnerRectUniform; |
153 GrGLProgramDataManager::UniformHandle fRadiusPlusHalfUniform; | 148 GrGLProgramDataManager::UniformHandle fRadiusPlusHalfUniform; |
154 SkRRect fPrevRRect; | 149 SkRRect fPrevRRect; |
155 typedef GrGLFragmentProcessor INHERITED; | 150 typedef GrGLFragmentProcessor INHERITED; |
156 }; | 151 }; |
157 | 152 |
158 GLCircularRRectEffect::GLCircularRRectEffect(const GrBackendProcessorFactory& fa
ctory, | 153 GLCircularRRectEffect::GLCircularRRectEffect(const GrProcessor& ) { |
159 const GrProcessor& ) | |
160 : INHERITED (factory) { | |
161 fPrevRRect.setEmpty(); | 154 fPrevRRect.setEmpty(); |
162 } | 155 } |
163 | 156 |
164 void GLCircularRRectEffect::emitCode(GrGLFPBuilder* builder, | 157 void GLCircularRRectEffect::emitCode(GrGLFPBuilder* builder, |
165 const GrFragmentProcessor& fp, | 158 const GrFragmentProcessor& fp, |
166 const char* outputColor, | 159 const char* outputColor, |
167 const char* inputColor, | 160 const char* inputColor, |
168 const TransformedCoordsArray&, | 161 const TransformedCoordsArray&, |
169 const TextureSamplerArray& samplers) { | 162 const TextureSamplerArray& samplers) { |
170 const CircularRRectEffect& crre = fp.cast<CircularRRectEffect>(); | 163 const CircularRRectEffect& crre = fp.cast<CircularRRectEffect>(); |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
373 break; | 366 break; |
374 default: | 367 default: |
375 SkFAIL("Should have been one of the above cases."); | 368 SkFAIL("Should have been one of the above cases."); |
376 } | 369 } |
377 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.
fBottom); | 370 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.
fBottom); |
378 pdman.set1f(fRadiusPlusHalfUniform, radius + 0.5f); | 371 pdman.set1f(fRadiusPlusHalfUniform, radius + 0.5f); |
379 fPrevRRect = rrect; | 372 fPrevRRect = rrect; |
380 } | 373 } |
381 } | 374 } |
382 | 375 |
| 376 ////////////////////////////////////////////////////////////////////////////////
//////////////////// |
| 377 |
| 378 void CircularRRectEffect::getGLProcessorKey(const GrGLCaps& caps, |
| 379 GrProcessorKeyBuilder* b) const { |
| 380 GLCircularRRectEffect::GenKey(*this, caps, b); |
| 381 } |
| 382 |
| 383 GrGLFragmentProcessor* CircularRRectEffect::createGLInstance() const { |
| 384 return SkNEW_ARGS(GLCircularRRectEffect, (*this)); |
| 385 } |
| 386 |
383 ////////////////////////////////////////////////////////////////////////////// | 387 ////////////////////////////////////////////////////////////////////////////// |
384 | 388 |
385 class GLEllipticalRRectEffect; | |
386 | |
387 class EllipticalRRectEffect : public GrFragmentProcessor { | 389 class EllipticalRRectEffect : public GrFragmentProcessor { |
388 public: | 390 public: |
389 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&); | 391 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&); |
390 | 392 |
391 virtual ~EllipticalRRectEffect() {}; | 393 virtual ~EllipticalRRectEffect() {}; |
392 static const char* Name() { return "EllipticalRRect"; } | 394 |
| 395 virtual const char* name() const SK_OVERRIDE { return "EllipticalRRect"; } |
| 396 |
| 397 virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) cons
t SK_OVERRIDE; |
| 398 |
| 399 virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE; |
393 | 400 |
394 const SkRRect& getRRect() const { return fRRect; } | 401 const SkRRect& getRRect() const { return fRRect; } |
395 | 402 |
396 | |
397 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 403 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
398 | 404 |
399 typedef GLEllipticalRRectEffect GLProcessor; | |
400 | |
401 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; | |
402 | |
403 private: | 405 private: |
404 EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&); | 406 EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&); |
405 | 407 |
406 virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE; | 408 virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE; |
407 | 409 |
408 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 410 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
409 | 411 |
410 SkRRect fRRect; | 412 SkRRect fRRect; |
411 GrPrimitiveEdgeType fEdgeType; | 413 GrPrimitiveEdgeType fEdgeType; |
412 | 414 |
413 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 415 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
414 | 416 |
415 typedef GrFragmentProcessor INHERITED; | 417 typedef GrFragmentProcessor INHERITED; |
416 }; | 418 }; |
417 | 419 |
418 GrFragmentProcessor* | 420 GrFragmentProcessor* |
419 EllipticalRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect
) { | 421 EllipticalRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect
) { |
420 if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdg
eType != edgeType) { | 422 if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdg
eType != edgeType) { |
421 return NULL; | 423 return NULL; |
422 } | 424 } |
423 return SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrect)); | 425 return SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrect)); |
424 } | 426 } |
425 | 427 |
426 void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) c
onst { | 428 void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) c
onst { |
427 inout->mulByUnknownAlpha(); | 429 inout->mulByUnknownAlpha(); |
428 } | 430 } |
429 | 431 |
430 const GrBackendFragmentProcessorFactory& EllipticalRRectEffect::getFactory() con
st { | |
431 return GrTBackendFragmentProcessorFactory<EllipticalRRectEffect>::getInstanc
e(); | |
432 } | |
433 | |
434 EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const
SkRRect& rrect) | 432 EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const
SkRRect& rrect) |
435 : fRRect(rrect) | 433 : fRRect(rrect) |
436 , fEdgeType(edgeType){ | 434 , fEdgeType(edgeType) { |
| 435 this->initClassID<EllipticalRRectEffect>(); |
437 this->setWillReadFragmentPosition(); | 436 this->setWillReadFragmentPosition(); |
438 } | 437 } |
439 | 438 |
440 bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { | 439 bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { |
441 const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>(); | 440 const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>(); |
442 return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect; | 441 return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect; |
443 } | 442 } |
444 | 443 |
445 ////////////////////////////////////////////////////////////////////////////// | 444 ////////////////////////////////////////////////////////////////////////////// |
446 | 445 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
481 GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)random->nextULessThan(kGrP
rocessorEdgeTypeCnt); | 480 GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)random->nextULessThan(kGrP
rocessorEdgeTypeCnt); |
482 fp = GrRRectEffect::Create(et, rrect); | 481 fp = GrRRectEffect::Create(et, rrect); |
483 } while (NULL == fp); | 482 } while (NULL == fp); |
484 return fp; | 483 return fp; |
485 } | 484 } |
486 | 485 |
487 ////////////////////////////////////////////////////////////////////////////// | 486 ////////////////////////////////////////////////////////////////////////////// |
488 | 487 |
489 class GLEllipticalRRectEffect : public GrGLFragmentProcessor { | 488 class GLEllipticalRRectEffect : public GrGLFragmentProcessor { |
490 public: | 489 public: |
491 GLEllipticalRRectEffect(const GrBackendProcessorFactory&, const GrProcessor&
); | 490 GLEllipticalRRectEffect(const GrProcessor&); |
492 | 491 |
493 virtual void emitCode(GrGLFPBuilder* builder, | 492 virtual void emitCode(GrGLFPBuilder* builder, |
494 const GrFragmentProcessor& effect, | 493 const GrFragmentProcessor& effect, |
495 const char* outputColor, | 494 const char* outputColor, |
496 const char* inputColor, | 495 const char* inputColor, |
497 const TransformedCoordsArray&, | 496 const TransformedCoordsArray&, |
498 const TextureSamplerArray&) SK_OVERRIDE; | 497 const TextureSamplerArray&) SK_OVERRIDE; |
499 | 498 |
500 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 499 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
501 | 500 |
502 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 501 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
503 | 502 |
504 private: | 503 private: |
505 GrGLProgramDataManager::UniformHandle fInnerRectUniform; | 504 GrGLProgramDataManager::UniformHandle fInnerRectUniform; |
506 GrGLProgramDataManager::UniformHandle fInvRadiiSqdUniform; | 505 GrGLProgramDataManager::UniformHandle fInvRadiiSqdUniform; |
507 SkRRect fPrevRRect; | 506 SkRRect fPrevRRect; |
508 typedef GrGLFragmentProcessor INHERITED; | 507 typedef GrGLFragmentProcessor INHERITED; |
509 }; | 508 }; |
510 | 509 |
511 GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrBackendProcessorFactory
& factory, | 510 GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrProcessor& effect) { |
512 const GrProcessor& effect) | |
513 : INHERITED (factory) { | |
514 fPrevRRect.setEmpty(); | 511 fPrevRRect.setEmpty(); |
515 } | 512 } |
516 | 513 |
517 void GLEllipticalRRectEffect::emitCode(GrGLFPBuilder* builder, | 514 void GLEllipticalRRectEffect::emitCode(GrGLFPBuilder* builder, |
518 const GrFragmentProcessor& effect, | 515 const GrFragmentProcessor& effect, |
519 const char* outputColor, | 516 const char* outputColor, |
520 const char* inputColor, | 517 const char* inputColor, |
521 const TransformedCoordsArray&, | 518 const TransformedCoordsArray&, |
522 const TextureSamplerArray& samplers) { | 519 const TextureSamplerArray& samplers) { |
523 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>(); | 520 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>(); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
627 break; | 624 break; |
628 } | 625 } |
629 default: | 626 default: |
630 SkFAIL("RRect should always be simple or nine-patch."); | 627 SkFAIL("RRect should always be simple or nine-patch."); |
631 } | 628 } |
632 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.
fBottom); | 629 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.
fBottom); |
633 fPrevRRect = rrect; | 630 fPrevRRect = rrect; |
634 } | 631 } |
635 } | 632 } |
636 | 633 |
| 634 ////////////////////////////////////////////////////////////////////////////////
//////////////////// |
| 635 |
| 636 void EllipticalRRectEffect::getGLProcessorKey(const GrGLCaps& caps, |
| 637 GrProcessorKeyBuilder* b) const { |
| 638 GLEllipticalRRectEffect::GenKey(*this, caps, b); |
| 639 } |
| 640 |
| 641 GrGLFragmentProcessor* EllipticalRRectEffect::createGLInstance() const { |
| 642 return SkNEW_ARGS(GLEllipticalRRectEffect, (*this)); |
| 643 } |
| 644 |
637 ////////////////////////////////////////////////////////////////////////////// | 645 ////////////////////////////////////////////////////////////////////////////// |
638 | 646 |
639 GrFragmentProcessor* GrRRectEffect::Create(GrPrimitiveEdgeType edgeType, const S
kRRect& rrect) { | 647 GrFragmentProcessor* GrRRectEffect::Create(GrPrimitiveEdgeType edgeType, const S
kRRect& rrect) { |
640 if (rrect.isRect()) { | 648 if (rrect.isRect()) { |
641 return GrConvexPolyEffect::Create(edgeType, rrect.getBounds()); | 649 return GrConvexPolyEffect::Create(edgeType, rrect.getBounds()); |
642 } | 650 } |
643 | 651 |
644 if (rrect.isOval()) { | 652 if (rrect.isOval()) { |
645 return GrOvalEffect::Create(edgeType, rrect.getBounds()); | 653 return GrOvalEffect::Create(edgeType, rrect.getBounds()); |
646 } | 654 } |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
725 if (rrect.isNinePatch()) { | 733 if (rrect.isNinePatch()) { |
726 return EllipticalRRectEffect::Create(edgeType, rrect); | 734 return EllipticalRRectEffect::Create(edgeType, rrect); |
727 } | 735 } |
728 return NULL; | 736 return NULL; |
729 } | 737 } |
730 } | 738 } |
731 } | 739 } |
732 | 740 |
733 return NULL; | 741 return NULL; |
734 } | 742 } |
OLD | NEW |