OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 The Android Open Source Project |
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 "SkGradientShaderPriv.h" | 8 #include "SkGradientShaderPriv.h" |
9 #include "SkLinearGradient.h" | 9 #include "SkLinearGradient.h" |
10 #include "SkRadialGradient.h" | 10 #include "SkRadialGradient.h" |
11 #include "SkTwoPointRadialGradient.h" | 11 #include "SkTwoPointRadialGradient.h" |
12 #include "SkTwoPointConicalGradient.h" | 12 #include "SkTwoPointConicalGradient.h" |
13 #include "SkSweepGradient.h" | 13 #include "SkSweepGradient.h" |
14 | 14 |
15 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatri
x* localMatrix) | 15 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatri
x* localMatrix) |
16 : INHERITED(localMatrix) | 16 : INHERITED(localMatrix) |
17 { | 17 { |
18 SkASSERT(desc.fCount > 1); | 18 SkASSERT(desc.fCount > 1); |
19 | 19 |
20 fMapper = desc.fMapper; | |
21 SkSafeRef(fMapper); | |
22 fGradFlags = SkToU8(desc.fGradFlags); | 20 fGradFlags = SkToU8(desc.fGradFlags); |
23 | 21 |
24 SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount); | 22 SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount); |
25 SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs)); | 23 SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs)); |
26 fTileMode = desc.fTileMode; | 24 fTileMode = desc.fTileMode; |
27 fTileProc = gTileProcs[desc.fTileMode]; | 25 fTileProc = gTileProcs[desc.fTileMode]; |
28 | 26 |
29 /* Note: we let the caller skip the first and/or last position. | 27 /* Note: we let the caller skip the first and/or last position. |
30 i.e. pos[0] = 0.3, pos[1] = 0.7 | 28 i.e. pos[0] = 0.3, pos[1] = 0.7 |
31 In these cases, we insert dummy entries to ensure that the final data | 29 In these cases, we insert dummy entries to ensure that the final data |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 | 133 |
136 static SkShader::TileMode unpack_mode(uint32_t packed) { | 134 static SkShader::TileMode unpack_mode(uint32_t packed) { |
137 return (SkShader::TileMode)(packed & 0xF); | 135 return (SkShader::TileMode)(packed & 0xF); |
138 } | 136 } |
139 | 137 |
140 static uint32_t unpack_flags(uint32_t packed) { | 138 static uint32_t unpack_flags(uint32_t packed) { |
141 return packed >> 4; | 139 return packed >> 4; |
142 } | 140 } |
143 | 141 |
144 SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buf
fer) { | 142 SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buf
fer) { |
145 fMapper = buffer.readUnitMapper(); | 143 if (buffer.isVersionLT(SkReadBuffer::kNoUnitMappers_Version)) { |
| 144 // skip the old SkUnitMapper slot |
| 145 buffer.skipFlattenable(); |
| 146 } |
146 | 147 |
147 int colorCount = fColorCount = buffer.getArrayCount(); | 148 int colorCount = fColorCount = buffer.getArrayCount(); |
148 if (colorCount > kColorStorageCount) { | 149 if (colorCount > kColorStorageCount) { |
149 size_t allocSize = (sizeof(SkColor) + sizeof(SkPMColor) + sizeof(Rec)) *
colorCount; | 150 size_t allocSize = (sizeof(SkColor) + sizeof(SkPMColor) + sizeof(Rec)) *
colorCount; |
150 if (buffer.validateAvailable(allocSize)) { | 151 if (buffer.validateAvailable(allocSize)) { |
151 fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize))
; | 152 fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize))
; |
152 } else { | 153 } else { |
153 fOrigColors = NULL; | 154 fOrigColors = NULL; |
154 colorCount = fColorCount = 0; | 155 colorCount = fColorCount = 0; |
155 } | 156 } |
(...skipping 18 matching lines...) Expand all Loading... |
174 } | 175 } |
175 } | 176 } |
176 buffer.readMatrix(&fPtsToUnit); | 177 buffer.readMatrix(&fPtsToUnit); |
177 this->initCommon(); | 178 this->initCommon(); |
178 } | 179 } |
179 | 180 |
180 SkGradientShaderBase::~SkGradientShaderBase() { | 181 SkGradientShaderBase::~SkGradientShaderBase() { |
181 if (fOrigColors != fStorage) { | 182 if (fOrigColors != fStorage) { |
182 sk_free(fOrigColors); | 183 sk_free(fOrigColors); |
183 } | 184 } |
184 SkSafeUnref(fMapper); | |
185 } | 185 } |
186 | 186 |
187 void SkGradientShaderBase::initCommon() { | 187 void SkGradientShaderBase::initCommon() { |
188 unsigned colorAlpha = 0xFF; | 188 unsigned colorAlpha = 0xFF; |
189 for (int i = 0; i < fColorCount; i++) { | 189 for (int i = 0; i < fColorCount; i++) { |
190 colorAlpha &= SkColorGetA(fOrigColors[i]); | 190 colorAlpha &= SkColorGetA(fOrigColors[i]); |
191 } | 191 } |
192 fColorsAreOpaque = colorAlpha == 0xFF; | 192 fColorsAreOpaque = colorAlpha == 0xFF; |
193 } | 193 } |
194 | 194 |
195 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const { | 195 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const { |
196 this->INHERITED::flatten(buffer); | 196 this->INHERITED::flatten(buffer); |
197 buffer.writeFlattenable(fMapper); | |
198 buffer.writeColorArray(fOrigColors, fColorCount); | 197 buffer.writeColorArray(fOrigColors, fColorCount); |
199 buffer.writeUInt(pack_mode_flags(fTileMode, fGradFlags)); | 198 buffer.writeUInt(pack_mode_flags(fTileMode, fGradFlags)); |
200 if (fColorCount > 2) { | 199 if (fColorCount > 2) { |
201 Rec* recs = fRecs; | 200 Rec* recs = fRecs; |
202 for (int i = 1; i < fColorCount; i++) { | 201 for (int i = 1; i < fColorCount; i++) { |
203 buffer.writeInt(recs[i].fPos); | 202 buffer.writeInt(recs[i].fPos); |
204 buffer.writeUInt(recs[i].fScale); | 203 buffer.writeUInt(recs[i].fScale); |
205 } | 204 } |
206 } | 205 } |
207 buffer.writeMatrix(fPtsToUnit); | 206 buffer.writeMatrix(fPtsToUnit); |
(...skipping 270 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
478 b += db; | 477 b += db; |
479 } while (--count != 0); | 478 } while (--count != 0); |
480 } | 479 } |
481 } | 480 } |
482 | 481 |
483 static inline int SkFixedToFFFF(SkFixed x) { | 482 static inline int SkFixedToFFFF(SkFixed x) { |
484 SkASSERT((unsigned)x <= SK_Fixed1); | 483 SkASSERT((unsigned)x <= SK_Fixed1); |
485 return x - (x >> 16); | 484 return x - (x >> 16); |
486 } | 485 } |
487 | 486 |
488 static inline U16CPU bitsTo16(unsigned x, const unsigned bits) { | |
489 SkASSERT(x < (1U << bits)); | |
490 if (6 == bits) { | |
491 return (x << 10) | (x << 4) | (x >> 2); | |
492 } | |
493 if (8 == bits) { | |
494 return (x << 8) | x; | |
495 } | |
496 sk_throw(); | |
497 return 0; | |
498 } | |
499 | |
500 const uint16_t* SkGradientShaderBase::GradientShaderCache::getCache16() { | 487 const uint16_t* SkGradientShaderBase::GradientShaderCache::getCache16() { |
501 SkOnce(&fCache16Inited, &fCache16Mutex, SkGradientShaderBase::GradientShader
Cache::initCache16, | 488 SkOnce(&fCache16Inited, &fCache16Mutex, SkGradientShaderBase::GradientShader
Cache::initCache16, |
502 this); | 489 this); |
503 SkASSERT(fCache16); | 490 SkASSERT(fCache16); |
504 return fCache16; | 491 return fCache16; |
505 } | 492 } |
506 | 493 |
507 void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache*
cache) { | 494 void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache*
cache) { |
508 // double the count for dither entries | 495 // double the count for dither entries |
509 const int entryCount = kCache16Count * 2; | 496 const int entryCount = kCache16Count * 2; |
(...skipping 11 matching lines...) Expand all Loading... |
521 for (int i = 1; i < cache->fShader.fColorCount; i++) { | 508 for (int i = 1; i < cache->fShader.fColorCount; i++) { |
522 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift; | 509 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift; |
523 SkASSERT(nextIndex < kCache16Count); | 510 SkASSERT(nextIndex < kCache16Count); |
524 | 511 |
525 if (nextIndex > prevIndex) | 512 if (nextIndex > prevIndex) |
526 Build16bitCache(cache->fCache16 + prevIndex, cache->fShader.fOri
gColors[i-1], | 513 Build16bitCache(cache->fCache16 + prevIndex, cache->fShader.fOri
gColors[i-1], |
527 cache->fShader.fOrigColors[i], nextIndex - prevI
ndex + 1); | 514 cache->fShader.fOrigColors[i], nextIndex - prevI
ndex + 1); |
528 prevIndex = nextIndex; | 515 prevIndex = nextIndex; |
529 } | 516 } |
530 } | 517 } |
531 | |
532 if (cache->fShader.fMapper) { | |
533 cache->fCache16Storage = (uint16_t*)sk_malloc_throw(allocSize); | |
534 uint16_t* linear = cache->fCache16; // just computed linear data | |
535 uint16_t* mapped = cache->fCache16Storage; // storage for mapped data | |
536 SkUnitMapper* map = cache->fShader.fMapper; | |
537 for (int i = 0; i < kCache16Count; i++) { | |
538 int index = map->mapUnit16(bitsTo16(i, kCache16Bits)) >> kCache16Shi
ft; | |
539 mapped[i] = linear[index]; | |
540 mapped[i + kCache16Count] = linear[index + kCache16Count]; | |
541 } | |
542 sk_free(cache->fCache16); | |
543 cache->fCache16 = cache->fCache16Storage; | |
544 } | |
545 } | 518 } |
546 | 519 |
547 const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() { | 520 const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() { |
548 SkOnce(&fCache32Inited, &fCache32Mutex, SkGradientShaderBase::GradientShader
Cache::initCache32, | 521 SkOnce(&fCache32Inited, &fCache32Mutex, SkGradientShaderBase::GradientShader
Cache::initCache32, |
549 this); | 522 this); |
550 SkASSERT(fCache32); | 523 SkASSERT(fCache32); |
551 return fCache32; | 524 return fCache32; |
552 } | 525 } |
553 | 526 |
554 void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache*
cache) { | 527 void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache*
cache) { |
(...skipping 17 matching lines...) Expand all Loading... |
572 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift; | 545 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift; |
573 SkASSERT(nextIndex < kCache32Count); | 546 SkASSERT(nextIndex < kCache32Count); |
574 | 547 |
575 if (nextIndex > prevIndex) | 548 if (nextIndex > prevIndex) |
576 Build32bitCache(cache->fCache32 + prevIndex, cache->fShader.fOri
gColors[i-1], | 549 Build32bitCache(cache->fCache32 + prevIndex, cache->fShader.fOri
gColors[i-1], |
577 cache->fShader.fOrigColors[i], nextIndex - prevI
ndex + 1, | 550 cache->fShader.fOrigColors[i], nextIndex - prevI
ndex + 1, |
578 cache->fCacheAlpha, cache->fShader.fGradFlags); | 551 cache->fCacheAlpha, cache->fShader.fGradFlags); |
579 prevIndex = nextIndex; | 552 prevIndex = nextIndex; |
580 } | 553 } |
581 } | 554 } |
582 | |
583 if (cache->fShader.fMapper) { | |
584 SkMallocPixelRef* newPR = SkMallocPixelRef::NewAllocate(info, 0, NULL); | |
585 SkPMColor* linear = cache->fCache32; // just computed linear d
ata | |
586 SkPMColor* mapped = (SkPMColor*)newPR->getAddr(); // storage for mapp
ed data | |
587 SkUnitMapper* map = cache->fShader.fMapper; | |
588 for (int i = 0; i < kCache32Count; i++) { | |
589 int index = map->mapUnit16((i << 8) | i) >> 8; | |
590 mapped[i + kCache32Count*0] = linear[index + kCache32Count*0]; | |
591 mapped[i + kCache32Count*1] = linear[index + kCache32Count*1]; | |
592 mapped[i + kCache32Count*2] = linear[index + kCache32Count*2]; | |
593 mapped[i + kCache32Count*3] = linear[index + kCache32Count*3]; | |
594 } | |
595 cache->fCache32PixelRef->unref(); | |
596 cache->fCache32PixelRef = newPR; | |
597 cache->fCache32 = (SkPMColor*)newPR->getAddr(); | |
598 } | |
599 } | 555 } |
600 | 556 |
601 /* | 557 /* |
602 * The gradient holds a cache for the most recent value of alpha. Successive | 558 * The gradient holds a cache for the most recent value of alpha. Successive |
603 * callers with the same alpha value will share the same cache. | 559 * callers with the same alpha value will share the same cache. |
604 */ | 560 */ |
605 SkGradientShaderBase::GradientShaderCache* SkGradientShaderBase::refCache(U8CPU
alpha) const { | 561 SkGradientShaderBase::GradientShaderCache* SkGradientShaderBase::refCache(U8CPU
alpha) const { |
606 SkAutoMutexAcquire ama(fCacheMutex); | 562 SkAutoMutexAcquire ama(fCacheMutex); |
607 if (!fCache || fCache->getAlpha() != alpha) { | 563 if (!fCache || fCache->getAlpha() != alpha) { |
608 fCache.reset(SkNEW_ARGS(GradientShaderCache, (alpha, *this))); | 564 fCache.reset(SkNEW_ARGS(GradientShaderCache, (alpha, *this))); |
(...skipping 11 matching lines...) Expand all Loading... |
620 * allowing the client to utilize a cache of our bitmap (e.g. with a GPU). | 576 * allowing the client to utilize a cache of our bitmap (e.g. with a GPU). |
621 * To do that, we maintain a private cache of built-bitmaps, based on our | 577 * To do that, we maintain a private cache of built-bitmaps, based on our |
622 * colors and positions. Note: we don't try to flatten the fMapper, so if one | 578 * colors and positions. Note: we don't try to flatten the fMapper, so if one |
623 * is present, we skip the cache for now. | 579 * is present, we skip the cache for now. |
624 */ | 580 */ |
625 void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap) const { | 581 void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap) const { |
626 // our caller assumes no external alpha, so we ensure that our cache is | 582 // our caller assumes no external alpha, so we ensure that our cache is |
627 // built with 0xFF | 583 // built with 0xFF |
628 SkAutoTUnref<GradientShaderCache> cache(this->refCache(0xFF)); | 584 SkAutoTUnref<GradientShaderCache> cache(this->refCache(0xFF)); |
629 | 585 |
630 // don't have a way to put the mapper into our cache-key yet | |
631 if (fMapper) { | |
632 // force our cache32pixelref to be built | |
633 (void)cache->getCache32(); | |
634 bitmap->setConfig(SkImageInfo::MakeN32Premul(kCache32Count, 1)); | |
635 bitmap->setPixelRef(cache->getCache32PixelRef()); | |
636 return; | |
637 } | |
638 | |
639 // build our key: [numColors + colors[] + {positions[]} + flags ] | 586 // build our key: [numColors + colors[] + {positions[]} + flags ] |
640 int count = 1 + fColorCount + 1; | 587 int count = 1 + fColorCount + 1; |
641 if (fColorCount > 2) { | 588 if (fColorCount > 2) { |
642 count += fColorCount - 1; // fRecs[].fPos | 589 count += fColorCount - 1; // fRecs[].fPos |
643 } | 590 } |
644 | 591 |
645 SkAutoSTMalloc<16, int32_t> storage(count); | 592 SkAutoSTMalloc<16, int32_t> storage(count); |
646 int32_t* buffer = storage.get(); | 593 int32_t* buffer = storage.get(); |
647 | 594 |
648 *buffer++ = fColorCount; | 595 *buffer++ = fColorCount; |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
737 str->append(")"); | 684 str->append(")"); |
738 } | 685 } |
739 | 686 |
740 static const char* gTileModeName[SkShader::kTileModeCount] = { | 687 static const char* gTileModeName[SkShader::kTileModeCount] = { |
741 "clamp", "repeat", "mirror" | 688 "clamp", "repeat", "mirror" |
742 }; | 689 }; |
743 | 690 |
744 str->append(" "); | 691 str->append(" "); |
745 str->append(gTileModeName[fTileMode]); | 692 str->append(gTileModeName[fTileMode]); |
746 | 693 |
747 // TODO: add "fMapper->toString(str);" when SkUnitMapper::toString is added | |
748 | |
749 this->INHERITED::toString(str); | 694 this->INHERITED::toString(str); |
750 } | 695 } |
751 #endif | 696 #endif |
752 | 697 |
753 /////////////////////////////////////////////////////////////////////////////// | 698 /////////////////////////////////////////////////////////////////////////////// |
754 /////////////////////////////////////////////////////////////////////////////// | 699 /////////////////////////////////////////////////////////////////////////////// |
755 | 700 |
756 #include "SkEmptyShader.h" | 701 #include "SkEmptyShader.h" |
757 | 702 |
758 // assumes colors is SkColor* and pos is SkScalar* | 703 // assumes colors is SkColor* and pos is SkScalar* |
759 #define EXPAND_1_COLOR(count) \ | 704 #define EXPAND_1_COLOR(count) \ |
760 SkColor tmp[2]; \ | 705 SkColor tmp[2]; \ |
761 do { \ | 706 do { \ |
762 if (1 == count) { \ | 707 if (1 == count) { \ |
763 tmp[0] = tmp[1] = colors[0]; \ | 708 tmp[0] = tmp[1] = colors[0]; \ |
764 colors = tmp; \ | 709 colors = tmp; \ |
765 pos = NULL; \ | 710 pos = NULL; \ |
766 count = 2; \ | 711 count = 2; \ |
767 } \ | 712 } \ |
768 } while (0) | 713 } while (0) |
769 | 714 |
770 static void desc_init(SkGradientShaderBase::Descriptor* desc, | 715 static void desc_init(SkGradientShaderBase::Descriptor* desc, |
771 const SkColor colors[], | 716 const SkColor colors[], |
772 const SkScalar pos[], int colorCount, | 717 const SkScalar pos[], int colorCount, |
773 SkShader::TileMode mode, | 718 SkShader::TileMode mode, uint32_t flags) { |
774 SkUnitMapper* mapper, uint32_t flags) { | |
775 desc->fColors = colors; | 719 desc->fColors = colors; |
776 desc->fPos = pos; | 720 desc->fPos = pos; |
777 desc->fCount = colorCount; | 721 desc->fCount = colorCount; |
778 desc->fTileMode = mode; | 722 desc->fTileMode = mode; |
779 desc->fMapper = mapper; | |
780 desc->fGradFlags = flags; | 723 desc->fGradFlags = flags; |
781 } | 724 } |
782 | 725 |
783 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], | 726 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], |
784 const SkColor colors[], | 727 const SkColor colors[], |
785 const SkScalar pos[], int colorCount, | 728 const SkScalar pos[], int colorCount, |
786 SkShader::TileMode mode, | 729 SkShader::TileMode mode, |
787 SkUnitMapper* mapper, | |
788 uint32_t flags, | 730 uint32_t flags, |
789 const SkMatrix* localMatrix) { | 731 const SkMatrix* localMatrix) { |
790 if (NULL == pts || NULL == colors || colorCount < 1) { | 732 if (NULL == pts || NULL == colors || colorCount < 1) { |
791 return NULL; | 733 return NULL; |
792 } | 734 } |
793 EXPAND_1_COLOR(colorCount); | 735 EXPAND_1_COLOR(colorCount); |
794 | 736 |
795 SkGradientShaderBase::Descriptor desc; | 737 SkGradientShaderBase::Descriptor desc; |
796 desc_init(&desc, colors, pos, colorCount, mode, mapper, flags); | 738 desc_init(&desc, colors, pos, colorCount, mode, flags); |
797 return SkNEW_ARGS(SkLinearGradient, (pts, desc, localMatrix)); | 739 return SkNEW_ARGS(SkLinearGradient, (pts, desc, localMatrix)); |
798 } | 740 } |
799 | 741 |
800 SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, | 742 SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, |
801 const SkColor colors[], | 743 const SkColor colors[], |
802 const SkScalar pos[], int colorCount, | 744 const SkScalar pos[], int colorCount, |
803 SkShader::TileMode mode, | 745 SkShader::TileMode mode, |
804 SkUnitMapper* mapper, | |
805 uint32_t flags, | 746 uint32_t flags, |
806 const SkMatrix* localMatrix) { | 747 const SkMatrix* localMatrix) { |
807 if (radius <= 0 || NULL == colors || colorCount < 1) { | 748 if (radius <= 0 || NULL == colors || colorCount < 1) { |
808 return NULL; | 749 return NULL; |
809 } | 750 } |
810 EXPAND_1_COLOR(colorCount); | 751 EXPAND_1_COLOR(colorCount); |
811 | 752 |
812 SkGradientShaderBase::Descriptor desc; | 753 SkGradientShaderBase::Descriptor desc; |
813 desc_init(&desc, colors, pos, colorCount, mode, mapper, flags); | 754 desc_init(&desc, colors, pos, colorCount, mode, flags); |
814 return SkNEW_ARGS(SkRadialGradient, (center, radius, desc, localMatrix)); | 755 return SkNEW_ARGS(SkRadialGradient, (center, radius, desc, localMatrix)); |
815 } | 756 } |
816 | 757 |
817 SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start, | 758 SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start, |
818 SkScalar startRadius, | 759 SkScalar startRadius, |
819 const SkPoint& end, | 760 const SkPoint& end, |
820 SkScalar endRadius, | 761 SkScalar endRadius, |
821 const SkColor colors[], | 762 const SkColor colors[], |
822 const SkScalar pos[], | 763 const SkScalar pos[], |
823 int colorCount, | 764 int colorCount, |
824 SkShader::TileMode mode, | 765 SkShader::TileMode mode, |
825 SkUnitMapper* mapper, | |
826 uint32_t flags, | 766 uint32_t flags, |
827 const SkMatrix* localMatrix) { | 767 const SkMatrix* localMatrix) { |
828 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { | 768 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { |
829 return NULL; | 769 return NULL; |
830 } | 770 } |
831 EXPAND_1_COLOR(colorCount); | 771 EXPAND_1_COLOR(colorCount); |
832 | 772 |
833 SkGradientShaderBase::Descriptor desc; | 773 SkGradientShaderBase::Descriptor desc; |
834 desc_init(&desc, colors, pos, colorCount, mode, mapper, flags); | 774 desc_init(&desc, colors, pos, colorCount, mode, flags); |
835 return SkNEW_ARGS(SkTwoPointRadialGradient, | 775 return SkNEW_ARGS(SkTwoPointRadialGradient, |
836 (start, startRadius, end, endRadius, desc, localMatrix)); | 776 (start, startRadius, end, endRadius, desc, localMatrix)); |
837 } | 777 } |
838 | 778 |
839 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, | 779 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, |
840 SkScalar startRadius, | 780 SkScalar startRadius, |
841 const SkPoint& end, | 781 const SkPoint& end, |
842 SkScalar endRadius, | 782 SkScalar endRadius, |
843 const SkColor colors[], | 783 const SkColor colors[], |
844 const SkScalar pos[], | 784 const SkScalar pos[], |
845 int colorCount, | 785 int colorCount, |
846 SkShader::TileMode mode, | 786 SkShader::TileMode mode, |
847 SkUnitMapper* mapper, | |
848 uint32_t flags, | 787 uint32_t flags, |
849 const SkMatrix* localMatrix) { | 788 const SkMatrix* localMatrix) { |
850 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { | 789 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { |
851 return NULL; | 790 return NULL; |
852 } | 791 } |
853 if (start == end && startRadius == endRadius) { | 792 if (start == end && startRadius == endRadius) { |
854 return SkNEW(SkEmptyShader); | 793 return SkNEW(SkEmptyShader); |
855 } | 794 } |
856 | 795 |
857 EXPAND_1_COLOR(colorCount); | 796 EXPAND_1_COLOR(colorCount); |
858 | 797 |
859 bool flipGradient = startRadius > endRadius; | 798 bool flipGradient = startRadius > endRadius; |
860 | 799 |
861 SkGradientShaderBase::Descriptor desc; | 800 SkGradientShaderBase::Descriptor desc; |
862 | 801 |
863 if (!flipGradient) { | 802 if (!flipGradient) { |
864 desc_init(&desc, colors, pos, colorCount, mode, mapper, flags); | 803 desc_init(&desc, colors, pos, colorCount, mode, flags); |
865 return SkNEW_ARGS(SkTwoPointConicalGradient, | 804 return SkNEW_ARGS(SkTwoPointConicalGradient, |
866 (start, startRadius, end, endRadius, flipGradient, des
c, localMatrix)); | 805 (start, startRadius, end, endRadius, flipGradient, des
c, localMatrix)); |
867 } else { | 806 } else { |
868 SkAutoSTArray<8, SkColor> colorsNew(colorCount); | 807 SkAutoSTArray<8, SkColor> colorsNew(colorCount); |
869 SkAutoSTArray<8, SkScalar> posNew(colorCount); | 808 SkAutoSTArray<8, SkScalar> posNew(colorCount); |
870 for (int i = 0; i < colorCount; ++i) { | 809 for (int i = 0; i < colorCount; ++i) { |
871 colorsNew[i] = colors[colorCount - i - 1]; | 810 colorsNew[i] = colors[colorCount - i - 1]; |
872 } | 811 } |
873 | 812 |
874 if (pos) { | 813 if (pos) { |
875 for (int i = 0; i < colorCount; ++i) { | 814 for (int i = 0; i < colorCount; ++i) { |
876 posNew[i] = 1 - pos[colorCount - i - 1]; | 815 posNew[i] = 1 - pos[colorCount - i - 1]; |
877 } | 816 } |
878 desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, ma
pper, flags); | 817 desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, fl
ags); |
879 } else { | 818 } else { |
880 desc_init(&desc, colorsNew.get(), NULL, colorCount, mode, mapper, fl
ags); | 819 desc_init(&desc, colorsNew.get(), NULL, colorCount, mode, flags); |
881 } | 820 } |
882 | 821 |
883 return SkNEW_ARGS(SkTwoPointConicalGradient, | 822 return SkNEW_ARGS(SkTwoPointConicalGradient, |
884 (end, endRadius, start, startRadius, flipGradient, des
c, localMatrix)); | 823 (end, endRadius, start, startRadius, flipGradient, des
c, localMatrix)); |
885 } | 824 } |
886 } | 825 } |
887 | 826 |
888 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, | 827 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, |
889 const SkColor colors[], | 828 const SkColor colors[], |
890 const SkScalar pos[], | 829 const SkScalar pos[], |
891 int colorCount, SkUnitMapper* mapper, | 830 int colorCount, |
892 uint32_t flags, | 831 uint32_t flags, |
893 const SkMatrix* localMatrix) { | 832 const SkMatrix* localMatrix) { |
894 if (NULL == colors || colorCount < 1) { | 833 if (NULL == colors || colorCount < 1) { |
895 return NULL; | 834 return NULL; |
896 } | 835 } |
897 EXPAND_1_COLOR(colorCount); | 836 EXPAND_1_COLOR(colorCount); |
898 | 837 |
899 SkGradientShaderBase::Descriptor desc; | 838 SkGradientShaderBase::Descriptor desc; |
900 desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, mapper,
flags); | 839 desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags); |
901 return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc, localMatrix)); | 840 return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc, localMatrix)); |
902 } | 841 } |
903 | 842 |
904 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) | 843 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) |
905 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient) | 844 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient) |
906 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient) | 845 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient) |
907 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient) | 846 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient) |
908 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient) | 847 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient) |
909 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient) | 848 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient) |
910 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 849 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
(...skipping 299 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1210 (*stops)[i] = stop; | 1149 (*stops)[i] = stop; |
1211 stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - st
op) : 1.f; | 1150 stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - st
op) : 1.f; |
1212 } | 1151 } |
1213 } | 1152 } |
1214 *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileM
odeCount)); | 1153 *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileM
odeCount)); |
1215 | 1154 |
1216 return outColors; | 1155 return outColors; |
1217 } | 1156 } |
1218 | 1157 |
1219 #endif | 1158 #endif |
OLD | NEW |