OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2012 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "SkRadialGradient.h" | 9 #include "SkRadialGradient.h" |
10 #include "SkRadialGradient_Table.h" | 10 #include "SkRadialGradient_Table.h" |
(...skipping 444 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
455 | 455 |
456 typedef GrGLGradientEffect INHERITED; | 456 typedef GrGLGradientEffect INHERITED; |
457 | 457 |
458 }; | 458 }; |
459 | 459 |
460 ///////////////////////////////////////////////////////////////////// | 460 ///////////////////////////////////////////////////////////////////// |
461 | 461 |
462 class GrRadialGradient : public GrGradientEffect { | 462 class GrRadialGradient : public GrGradientEffect { |
463 public: | 463 public: |
464 static GrFragmentProcessor* Create(GrContext* ctx, | 464 static GrFragmentProcessor* Create(GrContext* ctx, |
465 GrShaderDataManager* shaderDataManager, | 465 GrProcessorDataManager* procDataManager, |
466 const SkRadialGradient& shader, | 466 const SkRadialGradient& shader, |
467 const SkMatrix& matrix, | 467 const SkMatrix& matrix, |
468 SkShader::TileMode tm) { | 468 SkShader::TileMode tm) { |
469 return SkNEW_ARGS(GrRadialGradient, (ctx, shaderDataManager, shader, mat
rix, tm)); | 469 return SkNEW_ARGS(GrRadialGradient, (ctx, procDataManager, shader, matri
x, tm)); |
470 } | 470 } |
471 | 471 |
472 virtual ~GrRadialGradient() { } | 472 virtual ~GrRadialGradient() { } |
473 | 473 |
474 const char* name() const override { return "Radial Gradient"; } | 474 const char* name() const override { return "Radial Gradient"; } |
475 | 475 |
476 virtual void getGLProcessorKey(const GrGLSLCaps& caps, | 476 virtual void getGLProcessorKey(const GrGLSLCaps& caps, |
477 GrProcessorKeyBuilder* b) const override { | 477 GrProcessorKeyBuilder* b) const override { |
478 GrGLRadialGradient::GenKey(*this, caps, b); | 478 GrGLRadialGradient::GenKey(*this, caps, b); |
479 } | 479 } |
480 | 480 |
481 GrGLFragmentProcessor* createGLInstance() const override { | 481 GrGLFragmentProcessor* createGLInstance() const override { |
482 return SkNEW_ARGS(GrGLRadialGradient, (*this)); | 482 return SkNEW_ARGS(GrGLRadialGradient, (*this)); |
483 } | 483 } |
484 | 484 |
485 private: | 485 private: |
486 GrRadialGradient(GrContext* ctx, | 486 GrRadialGradient(GrContext* ctx, |
487 GrShaderDataManager* shaderDataManager, | 487 GrProcessorDataManager* procDataManager, |
488 const SkRadialGradient& shader, | 488 const SkRadialGradient& shader, |
489 const SkMatrix& matrix, | 489 const SkMatrix& matrix, |
490 SkShader::TileMode tm) | 490 SkShader::TileMode tm) |
491 : INHERITED(ctx, shaderDataManager, shader, matrix, tm) { | 491 : INHERITED(ctx, procDataManager, shader, matrix, tm) { |
492 this->initClassID<GrRadialGradient>(); | 492 this->initClassID<GrRadialGradient>(); |
493 } | 493 } |
494 | 494 |
495 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 495 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
496 | 496 |
497 typedef GrGradientEffect INHERITED; | 497 typedef GrGradientEffect INHERITED; |
498 }; | 498 }; |
499 | 499 |
500 ///////////////////////////////////////////////////////////////////// | 500 ///////////////////////////////////////////////////////////////////// |
501 | 501 |
502 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient); | 502 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient); |
503 | 503 |
504 GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) { | 504 GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) { |
505 SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; | 505 SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; |
506 SkScalar radius = d->fRandom->nextUScalar1(); | 506 SkScalar radius = d->fRandom->nextUScalar1(); |
507 | 507 |
508 SkColor colors[kMaxRandomGradientColors]; | 508 SkColor colors[kMaxRandomGradientColors]; |
509 SkScalar stopsArray[kMaxRandomGradientColors]; | 509 SkScalar stopsArray[kMaxRandomGradientColors]; |
510 SkScalar* stops = stopsArray; | 510 SkScalar* stops = stopsArray; |
511 SkShader::TileMode tm; | 511 SkShader::TileMode tm; |
512 int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); | 512 int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); |
513 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, | 513 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, |
514 colors, stops,
colorCount, | 514 colors, stops,
colorCount, |
515 tm)); | 515 tm)); |
516 SkPaint paint; | 516 SkPaint paint; |
517 GrColor paintColor; | 517 GrColor paintColor; |
518 GrFragmentProcessor* fp; | 518 GrFragmentProcessor* fp; |
519 SkAssertResult(shader->asFragmentProcessor(d->fContext, paint, | 519 SkAssertResult(shader->asFragmentProcessor(d->fContext, paint, |
520 GrTest::TestMatrix(d->fRandom), N
ULL, | 520 GrTest::TestMatrix(d->fRandom), N
ULL, |
521 &paintColor, d->fShaderDataManage
r, &fp)); | 521 &paintColor, d->fProcDataManager,
&fp)); |
522 return fp; | 522 return fp; |
523 } | 523 } |
524 | 524 |
525 ///////////////////////////////////////////////////////////////////// | 525 ///////////////////////////////////////////////////////////////////// |
526 | 526 |
527 void GrGLRadialGradient::emitCode(GrGLFPBuilder* builder, | 527 void GrGLRadialGradient::emitCode(GrGLFPBuilder* builder, |
528 const GrFragmentProcessor& fp, | 528 const GrFragmentProcessor& fp, |
529 const char* outputColor, | 529 const char* outputColor, |
530 const char* inputColor, | 530 const char* inputColor, |
531 const TransformedCoordsArray& coords, | 531 const TransformedCoordsArray& coords, |
532 const TextureSamplerArray& samplers) { | 532 const TextureSamplerArray& samplers) { |
533 const GrRadialGradient& ge = fp.cast<GrRadialGradient>(); | 533 const GrRadialGradient& ge = fp.cast<GrRadialGradient>(); |
534 this->emitUniforms(builder, ge); | 534 this->emitUniforms(builder, ge); |
535 SkString t("length("); | 535 SkString t("length("); |
536 t.append(builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0)); | 536 t.append(builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0)); |
537 t.append(")"); | 537 t.append(")"); |
538 this->emitColor(builder, ge, t.c_str(), outputColor, inputColor, samplers); | 538 this->emitColor(builder, ge, t.c_str(), outputColor, inputColor, samplers); |
539 } | 539 } |
540 | 540 |
541 ///////////////////////////////////////////////////////////////////// | 541 ///////////////////////////////////////////////////////////////////// |
542 | 542 |
543 bool SkRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& pa
int, | 543 bool SkRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& pa
int, |
544 const SkMatrix& viewM, | 544 const SkMatrix& viewM, |
545 const SkMatrix* localMatrix, GrColor*
paintColor, | 545 const SkMatrix* localMatrix, GrColor*
paintColor, |
546 GrShaderDataManager* shaderDataManage
r, | 546 GrProcessorDataManager* procDataManag
er, |
547 GrFragmentProcessor** fp) const { | 547 GrFragmentProcessor** fp) const { |
548 SkASSERT(context); | 548 SkASSERT(context); |
549 | 549 |
550 SkMatrix matrix; | 550 SkMatrix matrix; |
551 if (!this->getLocalMatrix().invert(&matrix)) { | 551 if (!this->getLocalMatrix().invert(&matrix)) { |
552 return false; | 552 return false; |
553 } | 553 } |
554 if (localMatrix) { | 554 if (localMatrix) { |
555 SkMatrix inv; | 555 SkMatrix inv; |
556 if (!localMatrix->invert(&inv)) { | 556 if (!localMatrix->invert(&inv)) { |
557 return false; | 557 return false; |
558 } | 558 } |
559 matrix.postConcat(inv); | 559 matrix.postConcat(inv); |
560 } | 560 } |
561 matrix.postConcat(fPtsToUnit); | 561 matrix.postConcat(fPtsToUnit); |
562 | 562 |
563 *paintColor = SkColor2GrColorJustAlpha(paint.getColor()); | 563 *paintColor = SkColor2GrColorJustAlpha(paint.getColor()); |
564 *fp = GrRadialGradient::Create(context, shaderDataManager, *this, matrix, fT
ileMode); | 564 *fp = GrRadialGradient::Create(context, procDataManager, *this, matrix, fTil
eMode); |
565 | 565 |
566 return true; | 566 return true; |
567 } | 567 } |
568 | 568 |
569 #else | 569 #else |
570 | 570 |
571 bool SkRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkM
atrix&, | 571 bool SkRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkM
atrix&, |
572 const SkMatrix*, GrColor*, GrShaderDa
taManager*, | 572 const SkMatrix*, GrColor*, GrProcesso
rDataManager*, |
573 GrFragmentProcessor**) const { | 573 GrFragmentProcessor**) const { |
574 SkDEBUGFAIL("Should not call in GPU-less build"); | 574 SkDEBUGFAIL("Should not call in GPU-less build"); |
575 return false; | 575 return false; |
576 } | 576 } |
577 | 577 |
578 #endif | 578 #endif |
579 | 579 |
580 #ifndef SK_IGNORE_TO_STRING | 580 #ifndef SK_IGNORE_TO_STRING |
581 void SkRadialGradient::toString(SkString* str) const { | 581 void SkRadialGradient::toString(SkString* str) const { |
582 str->append("SkRadialGradient: ("); | 582 str->append("SkRadialGradient: ("); |
583 | 583 |
584 str->append("center: ("); | 584 str->append("center: ("); |
585 str->appendScalar(fCenter.fX); | 585 str->appendScalar(fCenter.fX); |
586 str->append(", "); | 586 str->append(", "); |
587 str->appendScalar(fCenter.fY); | 587 str->appendScalar(fCenter.fY); |
588 str->append(") radius: "); | 588 str->append(") radius: "); |
589 str->appendScalar(fRadius); | 589 str->appendScalar(fRadius); |
590 str->append(" "); | 590 str->append(" "); |
591 | 591 |
592 this->INHERITED::toString(str); | 592 this->INHERITED::toString(str); |
593 | 593 |
594 str->append(")"); | 594 str->append(")"); |
595 } | 595 } |
596 #endif | 596 #endif |
OLD | NEW |