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 451 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
462 *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift]; | 462 *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift]; |
463 dstX += SK_Scalar1; | 463 dstX += SK_Scalar1; |
464 } while (--count != 0); | 464 } while (--count != 0); |
465 } | 465 } |
466 } | 466 } |
467 | 467 |
468 ///////////////////////////////////////////////////////////////////// | 468 ///////////////////////////////////////////////////////////////////// |
469 | 469 |
470 #if SK_SUPPORT_GPU | 470 #if SK_SUPPORT_GPU |
471 | 471 |
472 #include "GrTBackendEffectFactory.h" | 472 #include "GrTBackendProcessorFactory.h" |
473 #include "gl/builders/GrGLProgramBuilder.h" | 473 #include "gl/builders/GrGLProgramBuilder.h" |
474 #include "SkGr.h" | 474 #include "SkGr.h" |
475 | 475 |
476 class GrGLRadialGradient : public GrGLGradientEffect { | 476 class GrGLRadialGradient : public GrGLGradientEffect { |
477 public: | 477 public: |
478 | 478 |
479 GrGLRadialGradient(const GrBackendEffectFactory& factory, | 479 GrGLRadialGradient(const GrBackendProcessorFactory& factory, |
480 const GrEffect&) : INHERITED (factory) { } | 480 const GrProcessor&) : INHERITED (factory) { } |
481 virtual ~GrGLRadialGradient() { } | 481 virtual ~GrGLRadialGradient() { } |
482 | 482 |
483 virtual void emitCode(GrGLProgramBuilder*, | 483 virtual void emitCode(GrGLProgramBuilder*, |
484 const GrEffect&, | 484 const GrFragmentProcessor&, |
485 const GrEffectKey&, | 485 const GrProcessorKey&, |
486 const char* outputColor, | 486 const char* outputColor, |
487 const char* inputColor, | 487 const char* inputColor, |
488 const TransformedCoordsArray&, | 488 const TransformedCoordsArray&, |
489 const TextureSamplerArray&) SK_OVERRIDE; | 489 const TextureSamplerArray&) SK_OVERRIDE; |
490 | 490 |
491 static void GenKey(const GrEffect& effect, const GrGLCaps&, GrEffectKeyBuild
er* b) { | 491 static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcesso
rKeyBuilder* b) { |
492 b->add32(GenBaseGradientKey(effect)); | 492 b->add32(GenBaseGradientKey(processor)); |
493 } | 493 } |
494 | 494 |
495 private: | 495 private: |
496 | 496 |
497 typedef GrGLGradientEffect INHERITED; | 497 typedef GrGLGradientEffect INHERITED; |
498 | 498 |
499 }; | 499 }; |
500 | 500 |
501 ///////////////////////////////////////////////////////////////////// | 501 ///////////////////////////////////////////////////////////////////// |
502 | 502 |
503 class GrRadialGradient : public GrGradientEffect { | 503 class GrRadialGradient : public GrGradientEffect { |
504 public: | 504 public: |
505 static GrEffect* Create(GrContext* ctx, | 505 static GrFragmentProcessor* Create(GrContext* ctx, |
506 const SkRadialGradient& shader, | 506 const SkRadialGradient& shader, |
507 const SkMatrix& matrix, | 507 const SkMatrix& matrix, |
508 SkShader::TileMode tm) { | 508 SkShader::TileMode tm) { |
509 return SkNEW_ARGS(GrRadialGradient, (ctx, shader, matrix, tm)); | 509 return SkNEW_ARGS(GrRadialGradient, (ctx, shader, matrix, tm)); |
510 } | 510 } |
511 | 511 |
512 virtual ~GrRadialGradient() { } | 512 virtual ~GrRadialGradient() { } |
513 | 513 |
514 static const char* Name() { return "Radial Gradient"; } | 514 static const char* Name() { return "Radial Gradient"; } |
515 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { | 515 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE { |
516 return GrTBackendEffectFactory<GrRadialGradient>::getInstance(); | 516 return GrTBackendFragmentProcessorFactory<GrRadialGradient>::getInstance
(); |
517 } | 517 } |
518 | 518 |
519 typedef GrGLRadialGradient GLEffect; | 519 typedef GrGLRadialGradient GLProcessor; |
520 | 520 |
521 private: | 521 private: |
522 GrRadialGradient(GrContext* ctx, | 522 GrRadialGradient(GrContext* ctx, |
523 const SkRadialGradient& shader, | 523 const SkRadialGradient& shader, |
524 const SkMatrix& matrix, | 524 const SkMatrix& matrix, |
525 SkShader::TileMode tm) | 525 SkShader::TileMode tm) |
526 : INHERITED(ctx, shader, matrix, tm) { | 526 : INHERITED(ctx, shader, matrix, tm) { |
527 } | 527 } |
528 | 528 |
529 GR_DECLARE_EFFECT_TEST; | 529 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
530 | 530 |
531 typedef GrGradientEffect INHERITED; | 531 typedef GrGradientEffect INHERITED; |
532 }; | 532 }; |
533 | 533 |
534 ///////////////////////////////////////////////////////////////////// | 534 ///////////////////////////////////////////////////////////////////// |
535 | 535 |
536 GR_DEFINE_EFFECT_TEST(GrRadialGradient); | 536 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient); |
537 | 537 |
538 GrEffect* GrRadialGradient::TestCreate(SkRandom* random, | 538 GrFragmentProcessor* GrRadialGradient::TestCreate(SkRandom* random, |
539 GrContext* context, | 539 GrContext* context, |
540 const GrDrawTargetCaps&, | 540 const GrDrawTargetCaps&, |
541 GrTexture**) { | 541 GrTexture**) { |
542 SkPoint center = {random->nextUScalar1(), random->nextUScalar1()}; | 542 SkPoint center = {random->nextUScalar1(), random->nextUScalar1()}; |
543 SkScalar radius = random->nextUScalar1(); | 543 SkScalar radius = random->nextUScalar1(); |
544 | 544 |
545 SkColor colors[kMaxRandomGradientColors]; | 545 SkColor colors[kMaxRandomGradientColors]; |
546 SkScalar stopsArray[kMaxRandomGradientColors]; | 546 SkScalar stopsArray[kMaxRandomGradientColors]; |
547 SkScalar* stops = stopsArray; | 547 SkScalar* stops = stopsArray; |
548 SkShader::TileMode tm; | 548 SkShader::TileMode tm; |
549 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 549 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
550 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, | 550 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, |
551 colors, stops,
colorCount, | 551 colors, stops,
colorCount, |
552 tm)); | 552 tm)); |
553 SkPaint paint; | 553 SkPaint paint; |
554 GrColor paintColor; | 554 GrColor paintColor; |
555 GrEffect* effect; | 555 GrFragmentProcessor* fp; |
556 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 556 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &fp)); |
557 return effect; | 557 return fp; |
558 } | 558 } |
559 | 559 |
560 ///////////////////////////////////////////////////////////////////// | 560 ///////////////////////////////////////////////////////////////////// |
561 | 561 |
562 void GrGLRadialGradient::emitCode(GrGLProgramBuilder* builder, | 562 void GrGLRadialGradient::emitCode(GrGLProgramBuilder* builder, |
563 const GrEffect&, | 563 const GrFragmentProcessor&, |
564 const GrEffectKey& key, | 564 const GrProcessorKey& key, |
565 const char* outputColor, | 565 const char* outputColor, |
566 const char* inputColor, | 566 const char* inputColor, |
567 const TransformedCoordsArray& coords, | 567 const TransformedCoordsArray& coords, |
568 const TextureSamplerArray& samplers) { | 568 const TextureSamplerArray& samplers) { |
569 uint32_t baseKey = key.get32(0); | 569 uint32_t baseKey = key.get32(0); |
570 this->emitUniforms(builder, baseKey); | 570 this->emitUniforms(builder, baseKey); |
571 SkString t("length("); | 571 SkString t("length("); |
572 t.append(builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0)); | 572 t.append(builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0)); |
573 t.append(")"); | 573 t.append(")"); |
574 this->emitColor(builder, t.c_str(), baseKey, outputColor, inputColor, sample
rs); | 574 this->emitColor(builder, t.c_str(), baseKey, outputColor, inputColor, sample
rs); |
575 } | 575 } |
576 | 576 |
577 ///////////////////////////////////////////////////////////////////// | 577 ///////////////////////////////////////////////////////////////////// |
578 | 578 |
579 bool SkRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint, | 579 bool SkRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& pa
int, |
580 const SkMatrix* localMatrix, GrColor* paintCo
lor, | 580 const SkMatrix* localMatrix, GrColor*
paintColor, |
581 GrEffect** effect) const { | 581 GrFragmentProcessor** fp) const { |
582 SkASSERT(context); | 582 SkASSERT(context); |
583 | 583 |
584 SkMatrix matrix; | 584 SkMatrix matrix; |
585 if (!this->getLocalMatrix().invert(&matrix)) { | 585 if (!this->getLocalMatrix().invert(&matrix)) { |
586 return false; | 586 return false; |
587 } | 587 } |
588 if (localMatrix) { | 588 if (localMatrix) { |
589 SkMatrix inv; | 589 SkMatrix inv; |
590 if (!localMatrix->invert(&inv)) { | 590 if (!localMatrix->invert(&inv)) { |
591 return false; | 591 return false; |
592 } | 592 } |
593 matrix.postConcat(inv); | 593 matrix.postConcat(inv); |
594 } | 594 } |
595 matrix.postConcat(fPtsToUnit); | 595 matrix.postConcat(fPtsToUnit); |
596 | 596 |
597 *paintColor = SkColor2GrColorJustAlpha(paint.getColor()); | 597 *paintColor = SkColor2GrColorJustAlpha(paint.getColor()); |
598 *effect = GrRadialGradient::Create(context, *this, matrix, fTileMode); | 598 *fp = GrRadialGradient::Create(context, *this, matrix, fTileMode); |
599 | 599 |
600 return true; | 600 return true; |
601 } | 601 } |
602 | 602 |
603 #else | 603 #else |
604 | 604 |
605 bool SkRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint, | 605 bool SkRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkM
atrix*, GrColor*, |
606 const SkMatrix* localMatrix, GrColor* paintCo
lor, | 606 GrFragmentProcessor**) const { |
607 GrEffect** effect) const { | |
608 SkDEBUGFAIL("Should not call in GPU-less build"); | 607 SkDEBUGFAIL("Should not call in GPU-less build"); |
609 return false; | 608 return false; |
610 } | 609 } |
611 | 610 |
612 #endif | 611 #endif |
613 | 612 |
614 #ifndef SK_IGNORE_TO_STRING | 613 #ifndef SK_IGNORE_TO_STRING |
615 void SkRadialGradient::toString(SkString* str) const { | 614 void SkRadialGradient::toString(SkString* str) const { |
616 str->append("SkRadialGradient: ("); | 615 str->append("SkRadialGradient: ("); |
617 | 616 |
618 str->append("center: ("); | 617 str->append("center: ("); |
619 str->appendScalar(fCenter.fX); | 618 str->appendScalar(fCenter.fX); |
620 str->append(", "); | 619 str->append(", "); |
621 str->appendScalar(fCenter.fY); | 620 str->appendScalar(fCenter.fY); |
622 str->append(") radius: "); | 621 str->append(") radius: "); |
623 str->appendScalar(fRadius); | 622 str->appendScalar(fRadius); |
624 str->append(" "); | 623 str->append(" "); |
625 | 624 |
626 this->INHERITED::toString(str); | 625 this->INHERITED::toString(str); |
627 | 626 |
628 str->append(")"); | 627 str->append(")"); |
629 } | 628 } |
630 #endif | 629 #endif |
OLD | NEW |