SkGradientShader.cpp revision 4b8f8022550daa7458ed3de207d1300917d4a8cb
1/* 2 * Copyright 2006 The Android Open Source Project 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8#include "SkGradientShaderPriv.h" 9#include "SkLinearGradient.h" 10#include "SkRadialGradient.h" 11#include "SkTwoPointRadialGradient.h" 12#include "SkTwoPointConicalGradient.h" 13#include "SkSweepGradient.h" 14 15SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatrix* localMatrix) 16 : INHERITED(localMatrix) 17{ 18 SkASSERT(desc.fCount > 1); 19 20 fGradFlags = SkToU8(desc.fGradFlags); 21 22 SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount); 23 SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs)); 24 fTileMode = desc.fTileMode; 25 fTileProc = gTileProcs[desc.fTileMode]; 26 27 /* Note: we let the caller skip the first and/or last position. 28 i.e. pos[0] = 0.3, pos[1] = 0.7 29 In these cases, we insert dummy entries to ensure that the final data 30 will be bracketed by [0, 1]. 31 i.e. our_pos[0] = 0, our_pos[1] = 0.3, our_pos[2] = 0.7, our_pos[3] = 1 32 33 Thus colorCount (the caller's value, and fColorCount (our value) may 34 differ by up to 2. In the above example: 35 colorCount = 2 36 fColorCount = 4 37 */ 38 fColorCount = desc.fCount; 39 // check if we need to add in dummy start and/or end position/colors 40 bool dummyFirst = false; 41 bool dummyLast = false; 42 if (desc.fPos) { 43 dummyFirst = desc.fPos[0] != 0; 44 dummyLast = desc.fPos[desc.fCount - 1] != SK_Scalar1; 45 fColorCount += dummyFirst + dummyLast; 46 } 47 48 if (fColorCount > kColorStorageCount) { 49 size_t size = sizeof(SkColor) + sizeof(Rec); 50 fOrigColors = reinterpret_cast<SkColor*>( 51 sk_malloc_throw(size * fColorCount)); 52 } 53 else { 54 fOrigColors = fStorage; 55 } 56 57 // Now copy over the colors, adding the dummies as needed 58 { 59 SkColor* origColors = fOrigColors; 60 if (dummyFirst) { 61 *origColors++ = desc.fColors[0]; 62 } 63 memcpy(origColors, desc.fColors, desc.fCount * sizeof(SkColor)); 64 if (dummyLast) { 65 origColors += desc.fCount; 66 *origColors = desc.fColors[desc.fCount - 1]; 67 } 68 } 69 70 fRecs = (Rec*)(fOrigColors + fColorCount); 71 if (fColorCount > 2) { 72 Rec* recs = fRecs; 73 recs->fPos = 0; 74 // recs->fScale = 0; // unused; 75 recs += 1; 76 if (desc.fPos) { 77 /* We need to convert the user's array of relative positions into 78 fixed-point positions and scale factors. We need these results 79 to be strictly monotonic (no two values equal or out of order). 80 Hence this complex loop that just jams a zero for the scale 81 value if it sees a segment out of order, and it assures that 82 we start at 0 and end at 1.0 83 */ 84 SkFixed prev = 0; 85 int startIndex = dummyFirst ? 0 : 1; 86 int count = desc.fCount + dummyLast; 87 for (int i = startIndex; i < count; i++) { 88 // force the last value to be 1.0 89 SkFixed curr; 90 if (i == desc.fCount) { // we're really at the dummyLast 91 curr = SK_Fixed1; 92 } else { 93 curr = SkScalarToFixed(desc.fPos[i]); 94 } 95 // pin curr withing range 96 if (curr < 0) { 97 curr = 0; 98 } else if (curr > SK_Fixed1) { 99 curr = SK_Fixed1; 100 } 101 recs->fPos = curr; 102 if (curr > prev) { 103 recs->fScale = (1 << 24) / (curr - prev); 104 } else { 105 recs->fScale = 0; // ignore this segment 106 } 107 // get ready for the next value 108 prev = curr; 109 recs += 1; 110 } 111 } else { // assume even distribution 112 SkFixed dp = SK_Fixed1 / (desc.fCount - 1); 113 SkFixed p = dp; 114 SkFixed scale = (desc.fCount - 1) << 8; // (1 << 24) / dp 115 for (int i = 1; i < desc.fCount - 1; i++) { 116 recs->fPos = p; 117 recs->fScale = scale; 118 recs += 1; 119 p += dp; 120 } 121 recs->fPos = SK_Fixed1; 122 recs->fScale = scale; 123 } 124 } 125 this->initCommon(); 126} 127 128static uint32_t pack_mode_flags(SkShader::TileMode mode, uint32_t flags) { 129 SkASSERT(0 == (flags >> 28)); 130 SkASSERT(0 == ((uint32_t)mode >> 4)); 131 return (flags << 4) | mode; 132} 133 134static SkShader::TileMode unpack_mode(uint32_t packed) { 135 return (SkShader::TileMode)(packed & 0xF); 136} 137 138static uint32_t unpack_flags(uint32_t packed) { 139 return packed >> 4; 140} 141 142SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) { 143 if (buffer.isVersionLT(SkReadBuffer::kNoUnitMappers_Version)) { 144 // skip the old SkUnitMapper slot 145 buffer.skipFlattenable(); 146 } 147 148 int colorCount = fColorCount = buffer.getArrayCount(); 149 if (colorCount > kColorStorageCount) { 150 size_t allocSize = (sizeof(SkColor) + sizeof(SkPMColor) + sizeof(Rec)) * colorCount; 151 if (buffer.validateAvailable(allocSize)) { 152 fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize)); 153 } else { 154 fOrigColors = NULL; 155 colorCount = fColorCount = 0; 156 } 157 } else { 158 fOrigColors = fStorage; 159 } 160 buffer.readColorArray(fOrigColors, colorCount); 161 162 { 163 uint32_t packed = buffer.readUInt(); 164 fGradFlags = SkToU8(unpack_flags(packed)); 165 fTileMode = unpack_mode(packed); 166 } 167 fTileProc = gTileProcs[fTileMode]; 168 fRecs = (Rec*)(fOrigColors + colorCount); 169 if (colorCount > 2) { 170 Rec* recs = fRecs; 171 recs[0].fPos = 0; 172 for (int i = 1; i < colorCount; i++) { 173 recs[i].fPos = buffer.readInt(); 174 recs[i].fScale = buffer.readUInt(); 175 } 176 } 177 buffer.readMatrix(&fPtsToUnit); 178 this->initCommon(); 179} 180 181SkGradientShaderBase::~SkGradientShaderBase() { 182 if (fOrigColors != fStorage) { 183 sk_free(fOrigColors); 184 } 185} 186 187void SkGradientShaderBase::initCommon() { 188 unsigned colorAlpha = 0xFF; 189 for (int i = 0; i < fColorCount; i++) { 190 colorAlpha &= SkColorGetA(fOrigColors[i]); 191 } 192 fColorsAreOpaque = colorAlpha == 0xFF; 193} 194 195void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const { 196 this->INHERITED::flatten(buffer); 197 buffer.writeColorArray(fOrigColors, fColorCount); 198 buffer.writeUInt(pack_mode_flags(fTileMode, fGradFlags)); 199 if (fColorCount > 2) { 200 Rec* recs = fRecs; 201 for (int i = 1; i < fColorCount; i++) { 202 buffer.writeInt(recs[i].fPos); 203 buffer.writeUInt(recs[i].fScale); 204 } 205 } 206 buffer.writeMatrix(fPtsToUnit); 207} 208 209SkGradientShaderBase::GpuColorType SkGradientShaderBase::getGpuColorType(SkColor colors[3]) const { 210 if (fColorCount <= 3) { 211 memcpy(colors, fOrigColors, fColorCount * sizeof(SkColor)); 212 } 213 214 if (SkShader::kClamp_TileMode == fTileMode) { 215 if (2 == fColorCount) { 216 return kTwo_GpuColorType; 217 } else if (3 == fColorCount && 218 (SkScalarAbs( 219 SkFixedToScalar(fRecs[1].fPos) - SK_ScalarHalf) < SK_Scalar1 / 1000)) { 220 return kThree_GpuColorType; 221 } 222 } 223 return kTexture_GpuColorType; 224} 225 226void SkGradientShaderBase::FlipGradientColors(SkColor* colorDst, Rec* recDst, 227 SkColor* colorSrc, Rec* recSrc, 228 int count) { 229 SkAutoSTArray<8, SkColor> colorsTemp(count); 230 for (int i = 0; i < count; ++i) { 231 int offset = count - i - 1; 232 colorsTemp[i] = colorSrc[offset]; 233 } 234 if (count > 2) { 235 SkAutoSTArray<8, Rec> recsTemp(count); 236 for (int i = 0; i < count; ++i) { 237 int offset = count - i - 1; 238 recsTemp[i].fPos = SK_Fixed1 - recSrc[offset].fPos; 239 recsTemp[i].fScale = recSrc[offset].fScale; 240 } 241 memcpy(recDst, recsTemp.get(), count * sizeof(Rec)); 242 } 243 memcpy(colorDst, colorsTemp.get(), count * sizeof(SkColor)); 244} 245 246void SkGradientShaderBase::flipGradientColors() { 247 FlipGradientColors(fOrigColors, fRecs, fOrigColors, fRecs, fColorCount); 248} 249 250bool SkGradientShaderBase::isOpaque() const { 251 return fColorsAreOpaque; 252} 253 254SkGradientShaderBase::GradientShaderBaseContext::GradientShaderBaseContext( 255 const SkGradientShaderBase& shader, const ContextRec& rec) 256 : INHERITED(shader, rec) 257 , fCache(shader.refCache(getPaintAlpha())) 258{ 259 const SkMatrix& inverse = this->getTotalInverse(); 260 261 fDstToIndex.setConcat(shader.fPtsToUnit, inverse); 262 263 fDstToIndexProc = fDstToIndex.getMapXYProc(); 264 fDstToIndexClass = (uint8_t)SkShader::Context::ComputeMatrixClass(fDstToIndex); 265 266 // now convert our colors in to PMColors 267 unsigned paintAlpha = this->getPaintAlpha(); 268 269 fFlags = this->INHERITED::getFlags(); 270 if (shader.fColorsAreOpaque && paintAlpha == 0xFF) { 271 fFlags |= kOpaqueAlpha_Flag; 272 } 273 // we can do span16 as long as our individual colors are opaque, 274 // regardless of the paint's alpha 275 if (shader.fColorsAreOpaque) { 276 fFlags |= kHasSpan16_Flag; 277 } 278} 279 280SkGradientShaderBase::GradientShaderCache::GradientShaderCache( 281 U8CPU alpha, const SkGradientShaderBase& shader) 282 : fCacheAlpha(alpha) 283 , fShader(shader) 284 , fCache16Inited(false) 285 , fCache32Inited(false) 286{ 287 // Only initialize the cache in getCache16/32. 288 fCache16 = NULL; 289 fCache32 = NULL; 290 fCache16Storage = NULL; 291 fCache32PixelRef = NULL; 292} 293 294SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() { 295 sk_free(fCache16Storage); 296 SkSafeUnref(fCache32PixelRef); 297} 298 299#define Fixed_To_Dot8(x) (((x) + 0x80) >> 8) 300 301/** We take the original colors, not our premultiplied PMColors, since we can 302 build a 16bit table as long as the original colors are opaque, even if the 303 paint specifies a non-opaque alpha. 304*/ 305void SkGradientShaderBase::GradientShaderCache::Build16bitCache( 306 uint16_t cache[], SkColor c0, SkColor c1, int count) { 307 SkASSERT(count > 1); 308 SkASSERT(SkColorGetA(c0) == 0xFF); 309 SkASSERT(SkColorGetA(c1) == 0xFF); 310 311 SkFixed r = SkColorGetR(c0); 312 SkFixed g = SkColorGetG(c0); 313 SkFixed b = SkColorGetB(c0); 314 315 SkFixed dr = SkIntToFixed(SkColorGetR(c1) - r) / (count - 1); 316 SkFixed dg = SkIntToFixed(SkColorGetG(c1) - g) / (count - 1); 317 SkFixed db = SkIntToFixed(SkColorGetB(c1) - b) / (count - 1); 318 319 r = SkIntToFixed(r) + 0x8000; 320 g = SkIntToFixed(g) + 0x8000; 321 b = SkIntToFixed(b) + 0x8000; 322 323 do { 324 unsigned rr = r >> 16; 325 unsigned gg = g >> 16; 326 unsigned bb = b >> 16; 327 cache[0] = SkPackRGB16(SkR32ToR16(rr), SkG32ToG16(gg), SkB32ToB16(bb)); 328 cache[kCache16Count] = SkDitherPack888ToRGB16(rr, gg, bb); 329 cache += 1; 330 r += dr; 331 g += dg; 332 b += db; 333 } while (--count != 0); 334} 335 336/* 337 * r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in 338 * release builds, we saw a compiler error where the 0xFF parameter in 339 * SkPackARGB32() was being totally ignored whenever it was called with 340 * a non-zero add (e.g. 0x8000). 341 * 342 * We found two work-arounds: 343 * 1. change r,g,b to unsigned (or just one of them) 344 * 2. change SkPackARGB32 to + its (a << SK_A32_SHIFT) value instead 345 * of using | 346 * 347 * We chose #1 just because it was more localized. 348 * See http://code.google.com/p/skia/issues/detail?id=1113 349 * 350 * The type SkUFixed encapsulate this need for unsigned, but logically Fixed. 351 */ 352typedef uint32_t SkUFixed; 353 354void SkGradientShaderBase::GradientShaderCache::Build32bitCache( 355 SkPMColor cache[], SkColor c0, SkColor c1, 356 int count, U8CPU paintAlpha, uint32_t gradFlags) { 357 SkASSERT(count > 1); 358 359 // need to apply paintAlpha to our two endpoints 360 uint32_t a0 = SkMulDiv255Round(SkColorGetA(c0), paintAlpha); 361 uint32_t a1 = SkMulDiv255Round(SkColorGetA(c1), paintAlpha); 362 363 364 const bool interpInPremul = SkToBool(gradFlags & 365 SkGradientShader::kInterpolateColorsInPremul_Flag); 366 367 uint32_t r0 = SkColorGetR(c0); 368 uint32_t g0 = SkColorGetG(c0); 369 uint32_t b0 = SkColorGetB(c0); 370 371 uint32_t r1 = SkColorGetR(c1); 372 uint32_t g1 = SkColorGetG(c1); 373 uint32_t b1 = SkColorGetB(c1); 374 375 if (interpInPremul) { 376 r0 = SkMulDiv255Round(r0, a0); 377 g0 = SkMulDiv255Round(g0, a0); 378 b0 = SkMulDiv255Round(b0, a0); 379 380 r1 = SkMulDiv255Round(r1, a1); 381 g1 = SkMulDiv255Round(g1, a1); 382 b1 = SkMulDiv255Round(b1, a1); 383 } 384 385 SkFixed da = SkIntToFixed(a1 - a0) / (count - 1); 386 SkFixed dr = SkIntToFixed(r1 - r0) / (count - 1); 387 SkFixed dg = SkIntToFixed(g1 - g0) / (count - 1); 388 SkFixed db = SkIntToFixed(b1 - b0) / (count - 1); 389 390 /* We pre-add 1/8 to avoid having to add this to our [0] value each time 391 in the loop. Without this, the bias for each would be 392 0x2000 0xA000 0xE000 0x6000 393 With this trick, we can add 0 for the first (no-op) and just adjust the 394 others. 395 */ 396 SkUFixed a = SkIntToFixed(a0) + 0x2000; 397 SkUFixed r = SkIntToFixed(r0) + 0x2000; 398 SkUFixed g = SkIntToFixed(g0) + 0x2000; 399 SkUFixed b = SkIntToFixed(b0) + 0x2000; 400 401 /* 402 * Our dither-cell (spatially) is 403 * 0 2 404 * 3 1 405 * Where 406 * [0] -> [-1/8 ... 1/8 ) values near 0 407 * [1] -> [ 1/8 ... 3/8 ) values near 1/4 408 * [2] -> [ 3/8 ... 5/8 ) values near 1/2 409 * [3] -> [ 5/8 ... 7/8 ) values near 3/4 410 */ 411 412 if (0xFF == a0 && 0 == da) { 413 do { 414 cache[kCache32Count*0] = SkPackARGB32(0xFF, (r + 0 ) >> 16, 415 (g + 0 ) >> 16, 416 (b + 0 ) >> 16); 417 cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + 0x8000) >> 16, 418 (g + 0x8000) >> 16, 419 (b + 0x8000) >> 16); 420 cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + 0xC000) >> 16, 421 (g + 0xC000) >> 16, 422 (b + 0xC000) >> 16); 423 cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + 0x4000) >> 16, 424 (g + 0x4000) >> 16, 425 (b + 0x4000) >> 16); 426 cache += 1; 427 r += dr; 428 g += dg; 429 b += db; 430 } while (--count != 0); 431 } else if (interpInPremul) { 432 do { 433 cache[kCache32Count*0] = SkPackARGB32((a + 0 ) >> 16, 434 (r + 0 ) >> 16, 435 (g + 0 ) >> 16, 436 (b + 0 ) >> 16); 437 cache[kCache32Count*1] = SkPackARGB32((a + 0x8000) >> 16, 438 (r + 0x8000) >> 16, 439 (g + 0x8000) >> 16, 440 (b + 0x8000) >> 16); 441 cache[kCache32Count*2] = SkPackARGB32((a + 0xC000) >> 16, 442 (r + 0xC000) >> 16, 443 (g + 0xC000) >> 16, 444 (b + 0xC000) >> 16); 445 cache[kCache32Count*3] = SkPackARGB32((a + 0x4000) >> 16, 446 (r + 0x4000) >> 16, 447 (g + 0x4000) >> 16, 448 (b + 0x4000) >> 16); 449 cache += 1; 450 a += da; 451 r += dr; 452 g += dg; 453 b += db; 454 } while (--count != 0); 455 } else { // interpolate in unpreml space 456 do { 457 cache[kCache32Count*0] = SkPremultiplyARGBInline((a + 0 ) >> 16, 458 (r + 0 ) >> 16, 459 (g + 0 ) >> 16, 460 (b + 0 ) >> 16); 461 cache[kCache32Count*1] = SkPremultiplyARGBInline((a + 0x8000) >> 16, 462 (r + 0x8000) >> 16, 463 (g + 0x8000) >> 16, 464 (b + 0x8000) >> 16); 465 cache[kCache32Count*2] = SkPremultiplyARGBInline((a + 0xC000) >> 16, 466 (r + 0xC000) >> 16, 467 (g + 0xC000) >> 16, 468 (b + 0xC000) >> 16); 469 cache[kCache32Count*3] = SkPremultiplyARGBInline((a + 0x4000) >> 16, 470 (r + 0x4000) >> 16, 471 (g + 0x4000) >> 16, 472 (b + 0x4000) >> 16); 473 cache += 1; 474 a += da; 475 r += dr; 476 g += dg; 477 b += db; 478 } while (--count != 0); 479 } 480} 481 482static inline int SkFixedToFFFF(SkFixed x) { 483 SkASSERT((unsigned)x <= SK_Fixed1); 484 return x - (x >> 16); 485} 486 487static inline U16CPU bitsTo16(unsigned x, const unsigned bits) { 488 SkASSERT(x < (1U << bits)); 489 if (6 == bits) { 490 return (x << 10) | (x << 4) | (x >> 2); 491 } 492 if (8 == bits) { 493 return (x << 8) | x; 494 } 495 sk_throw(); 496 return 0; 497} 498 499const uint16_t* SkGradientShaderBase::GradientShaderCache::getCache16() { 500 SkOnce(&fCache16Inited, &fCache16Mutex, SkGradientShaderBase::GradientShaderCache::initCache16, 501 this); 502 SkASSERT(fCache16); 503 return fCache16; 504} 505 506void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache* cache) { 507 // double the count for dither entries 508 const int entryCount = kCache16Count * 2; 509 const size_t allocSize = sizeof(uint16_t) * entryCount; 510 511 SkASSERT(NULL == cache->fCache16Storage); 512 cache->fCache16Storage = (uint16_t*)sk_malloc_throw(allocSize); 513 cache->fCache16 = cache->fCache16Storage; 514 if (cache->fShader.fColorCount == 2) { 515 Build16bitCache(cache->fCache16, cache->fShader.fOrigColors[0], 516 cache->fShader.fOrigColors[1], kCache16Count); 517 } else { 518 Rec* rec = cache->fShader.fRecs; 519 int prevIndex = 0; 520 for (int i = 1; i < cache->fShader.fColorCount; i++) { 521 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift; 522 SkASSERT(nextIndex < kCache16Count); 523 524 if (nextIndex > prevIndex) 525 Build16bitCache(cache->fCache16 + prevIndex, cache->fShader.fOrigColors[i-1], 526 cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1); 527 prevIndex = nextIndex; 528 } 529 } 530} 531 532const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() { 533 SkOnce(&fCache32Inited, &fCache32Mutex, SkGradientShaderBase::GradientShaderCache::initCache32, 534 this); 535 SkASSERT(fCache32); 536 return fCache32; 537} 538 539void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache* cache) { 540 SkImageInfo info; 541 info.fWidth = kCache32Count; 542 info.fHeight = 4; // for our 4 dither rows 543 info.fAlphaType = kPremul_SkAlphaType; 544 info.fColorType = kN32_SkColorType; 545 546 SkASSERT(NULL == cache->fCache32PixelRef); 547 cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, NULL); 548 cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->getAddr(); 549 if (cache->fShader.fColorCount == 2) { 550 Build32bitCache(cache->fCache32, cache->fShader.fOrigColors[0], 551 cache->fShader.fOrigColors[1], kCache32Count, cache->fCacheAlpha, 552 cache->fShader.fGradFlags); 553 } else { 554 Rec* rec = cache->fShader.fRecs; 555 int prevIndex = 0; 556 for (int i = 1; i < cache->fShader.fColorCount; i++) { 557 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift; 558 SkASSERT(nextIndex < kCache32Count); 559 560 if (nextIndex > prevIndex) 561 Build32bitCache(cache->fCache32 + prevIndex, cache->fShader.fOrigColors[i-1], 562 cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1, 563 cache->fCacheAlpha, cache->fShader.fGradFlags); 564 prevIndex = nextIndex; 565 } 566 } 567} 568 569/* 570 * The gradient holds a cache for the most recent value of alpha. Successive 571 * callers with the same alpha value will share the same cache. 572 */ 573SkGradientShaderBase::GradientShaderCache* SkGradientShaderBase::refCache(U8CPU alpha) const { 574 SkAutoMutexAcquire ama(fCacheMutex); 575 if (!fCache || fCache->getAlpha() != alpha) { 576 fCache.reset(SkNEW_ARGS(GradientShaderCache, (alpha, *this))); 577 } 578 // Increment the ref counter inside the mutex to ensure the returned pointer is still valid. 579 // Otherwise, the pointer may have been overwritten on a different thread before the object's 580 // ref count was incremented. 581 fCache.get()->ref(); 582 return fCache; 583} 584 585/* 586 * Because our caller might rebuild the same (logically the same) gradient 587 * over and over, we'd like to return exactly the same "bitmap" if possible, 588 * allowing the client to utilize a cache of our bitmap (e.g. with a GPU). 589 * To do that, we maintain a private cache of built-bitmaps, based on our 590 * colors and positions. Note: we don't try to flatten the fMapper, so if one 591 * is present, we skip the cache for now. 592 */ 593void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap) const { 594 // our caller assumes no external alpha, so we ensure that our cache is 595 // built with 0xFF 596 SkAutoTUnref<GradientShaderCache> cache(this->refCache(0xFF)); 597 598 // build our key: [numColors + colors[] + {positions[]} + flags ] 599 int count = 1 + fColorCount + 1; 600 if (fColorCount > 2) { 601 count += fColorCount - 1; // fRecs[].fPos 602 } 603 604 SkAutoSTMalloc<16, int32_t> storage(count); 605 int32_t* buffer = storage.get(); 606 607 *buffer++ = fColorCount; 608 memcpy(buffer, fOrigColors, fColorCount * sizeof(SkColor)); 609 buffer += fColorCount; 610 if (fColorCount > 2) { 611 for (int i = 1; i < fColorCount; i++) { 612 *buffer++ = fRecs[i].fPos; 613 } 614 } 615 *buffer++ = fGradFlags; 616 SkASSERT(buffer - storage.get() == count); 617 618 /////////////////////////////////// 619 620 SK_DECLARE_STATIC_MUTEX(gMutex); 621 static SkBitmapCache* gCache; 622 // each cache cost 1K of RAM, since each bitmap will be 1x256 at 32bpp 623 static const int MAX_NUM_CACHED_GRADIENT_BITMAPS = 32; 624 SkAutoMutexAcquire ama(gMutex); 625 626 if (NULL == gCache) { 627 gCache = SkNEW_ARGS(SkBitmapCache, (MAX_NUM_CACHED_GRADIENT_BITMAPS)); 628 } 629 size_t size = count * sizeof(int32_t); 630 631 if (!gCache->find(storage.get(), size, bitmap)) { 632 // force our cahce32pixelref to be built 633 (void)cache->getCache32(); 634 bitmap->setConfig(SkImageInfo::MakeN32Premul(kCache32Count, 1)); 635 bitmap->setPixelRef(cache->getCache32PixelRef()); 636 637 gCache->add(storage.get(), size, *bitmap); 638 } 639} 640 641void SkGradientShaderBase::commonAsAGradient(GradientInfo* info, bool flipGrad) const { 642 if (info) { 643 if (info->fColorCount >= fColorCount) { 644 SkColor* colorLoc; 645 Rec* recLoc; 646 if (flipGrad && (info->fColors || info->fColorOffsets)) { 647 SkAutoSTArray<8, SkColor> colorStorage(fColorCount); 648 SkAutoSTArray<8, Rec> recStorage(fColorCount); 649 colorLoc = colorStorage.get(); 650 recLoc = recStorage.get(); 651 FlipGradientColors(colorLoc, recLoc, fOrigColors, fRecs, fColorCount); 652 } else { 653 colorLoc = fOrigColors; 654 recLoc = fRecs; 655 } 656 if (info->fColors) { 657 memcpy(info->fColors, colorLoc, fColorCount * sizeof(SkColor)); 658 } 659 if (info->fColorOffsets) { 660 if (fColorCount == 2) { 661 info->fColorOffsets[0] = 0; 662 info->fColorOffsets[1] = SK_Scalar1; 663 } else if (fColorCount > 2) { 664 for (int i = 0; i < fColorCount; ++i) { 665 info->fColorOffsets[i] = SkFixedToScalar(recLoc[i].fPos); 666 } 667 } 668 } 669 } 670 info->fColorCount = fColorCount; 671 info->fTileMode = fTileMode; 672 info->fGradientFlags = fGradFlags; 673 } 674} 675 676#ifndef SK_IGNORE_TO_STRING 677void SkGradientShaderBase::toString(SkString* str) const { 678 679 str->appendf("%d colors: ", fColorCount); 680 681 for (int i = 0; i < fColorCount; ++i) { 682 str->appendHex(fOrigColors[i]); 683 if (i < fColorCount-1) { 684 str->append(", "); 685 } 686 } 687 688 if (fColorCount > 2) { 689 str->append(" points: ("); 690 for (int i = 0; i < fColorCount; ++i) { 691 str->appendScalar(SkFixedToScalar(fRecs[i].fPos)); 692 if (i < fColorCount-1) { 693 str->append(", "); 694 } 695 } 696 str->append(")"); 697 } 698 699 static const char* gTileModeName[SkShader::kTileModeCount] = { 700 "clamp", "repeat", "mirror" 701 }; 702 703 str->append(" "); 704 str->append(gTileModeName[fTileMode]); 705 706 this->INHERITED::toString(str); 707} 708#endif 709 710/////////////////////////////////////////////////////////////////////////////// 711/////////////////////////////////////////////////////////////////////////////// 712 713#include "SkEmptyShader.h" 714 715// assumes colors is SkColor* and pos is SkScalar* 716#define EXPAND_1_COLOR(count) \ 717 SkColor tmp[2]; \ 718 do { \ 719 if (1 == count) { \ 720 tmp[0] = tmp[1] = colors[0]; \ 721 colors = tmp; \ 722 pos = NULL; \ 723 count = 2; \ 724 } \ 725 } while (0) 726 727static void desc_init(SkGradientShaderBase::Descriptor* desc, 728 const SkColor colors[], 729 const SkScalar pos[], int colorCount, 730 SkShader::TileMode mode, uint32_t flags) { 731 desc->fColors = colors; 732 desc->fPos = pos; 733 desc->fCount = colorCount; 734 desc->fTileMode = mode; 735 desc->fGradFlags = flags; 736} 737 738SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], 739 const SkColor colors[], 740 const SkScalar pos[], int colorCount, 741 SkShader::TileMode mode, 742 uint32_t flags, 743 const SkMatrix* localMatrix) { 744 if (NULL == pts || NULL == colors || colorCount < 1) { 745 return NULL; 746 } 747 EXPAND_1_COLOR(colorCount); 748 749 SkGradientShaderBase::Descriptor desc; 750 desc_init(&desc, colors, pos, colorCount, mode, flags); 751 return SkNEW_ARGS(SkLinearGradient, (pts, desc, localMatrix)); 752} 753 754SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, 755 const SkColor colors[], 756 const SkScalar pos[], int colorCount, 757 SkShader::TileMode mode, 758 uint32_t flags, 759 const SkMatrix* localMatrix) { 760 if (radius <= 0 || NULL == colors || colorCount < 1) { 761 return NULL; 762 } 763 EXPAND_1_COLOR(colorCount); 764 765 SkGradientShaderBase::Descriptor desc; 766 desc_init(&desc, colors, pos, colorCount, mode, flags); 767 return SkNEW_ARGS(SkRadialGradient, (center, radius, desc, localMatrix)); 768} 769 770SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start, 771 SkScalar startRadius, 772 const SkPoint& end, 773 SkScalar endRadius, 774 const SkColor colors[], 775 const SkScalar pos[], 776 int colorCount, 777 SkShader::TileMode mode, 778 uint32_t flags, 779 const SkMatrix* localMatrix) { 780 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { 781 return NULL; 782 } 783 EXPAND_1_COLOR(colorCount); 784 785 SkGradientShaderBase::Descriptor desc; 786 desc_init(&desc, colors, pos, colorCount, mode, flags); 787 return SkNEW_ARGS(SkTwoPointRadialGradient, 788 (start, startRadius, end, endRadius, desc, localMatrix)); 789} 790 791SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, 792 SkScalar startRadius, 793 const SkPoint& end, 794 SkScalar endRadius, 795 const SkColor colors[], 796 const SkScalar pos[], 797 int colorCount, 798 SkShader::TileMode mode, 799 uint32_t flags, 800 const SkMatrix* localMatrix) { 801 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { 802 return NULL; 803 } 804 if (start == end && startRadius == endRadius) { 805 return SkNEW(SkEmptyShader); 806 } 807 808 EXPAND_1_COLOR(colorCount); 809 810 bool flipGradient = startRadius > endRadius; 811 812 SkGradientShaderBase::Descriptor desc; 813 814 if (!flipGradient) { 815 desc_init(&desc, colors, pos, colorCount, mode, flags); 816 return SkNEW_ARGS(SkTwoPointConicalGradient, 817 (start, startRadius, end, endRadius, flipGradient, desc, localMatrix)); 818 } else { 819 SkAutoSTArray<8, SkColor> colorsNew(colorCount); 820 SkAutoSTArray<8, SkScalar> posNew(colorCount); 821 for (int i = 0; i < colorCount; ++i) { 822 colorsNew[i] = colors[colorCount - i - 1]; 823 } 824 825 if (pos) { 826 for (int i = 0; i < colorCount; ++i) { 827 posNew[i] = 1 - pos[colorCount - i - 1]; 828 } 829 desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, flags); 830 } else { 831 desc_init(&desc, colorsNew.get(), NULL, colorCount, mode, flags); 832 } 833 834 return SkNEW_ARGS(SkTwoPointConicalGradient, 835 (end, endRadius, start, startRadius, flipGradient, desc, localMatrix)); 836 } 837} 838 839SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, 840 const SkColor colors[], 841 const SkScalar pos[], 842 int colorCount, 843 uint32_t flags, 844 const SkMatrix* localMatrix) { 845 if (NULL == colors || colorCount < 1) { 846 return NULL; 847 } 848 EXPAND_1_COLOR(colorCount); 849 850 SkGradientShaderBase::Descriptor desc; 851 desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags); 852 return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc, localMatrix)); 853} 854 855SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) 856 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient) 857 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient) 858 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient) 859 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient) 860 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient) 861SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END 862 863/////////////////////////////////////////////////////////////////////////////// 864 865#if SK_SUPPORT_GPU 866 867#include "effects/GrTextureStripAtlas.h" 868#include "GrTBackendEffectFactory.h" 869#include "SkGr.h" 870 871GrGLGradientEffect::GrGLGradientEffect(const GrBackendEffectFactory& factory) 872 : INHERITED(factory) 873 , fCachedYCoord(SK_ScalarMax) { 874} 875 876GrGLGradientEffect::~GrGLGradientEffect() { } 877 878void GrGLGradientEffect::emitUniforms(GrGLShaderBuilder* builder, EffectKey key) { 879 880 if (SkGradientShaderBase::kTwo_GpuColorType == ColorTypeFromKey(key)) { // 2 Color case 881 fColorStartUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 882 kVec4f_GrSLType, "GradientStartColor"); 883 fColorEndUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 884 kVec4f_GrSLType, "GradientEndColor"); 885 886 } else if (SkGradientShaderBase::kThree_GpuColorType == ColorTypeFromKey(key)){ // 3 Color Case 887 fColorStartUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 888 kVec4f_GrSLType, "GradientStartColor"); 889 fColorMidUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 890 kVec4f_GrSLType, "GradientMidColor"); 891 fColorEndUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 892 kVec4f_GrSLType, "GradientEndColor"); 893 894 } else { // if not a fast case 895 fFSYUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 896 kFloat_GrSLType, "GradientYCoordFS"); 897 } 898} 899 900static inline void set_color_uni(const GrGLUniformManager& uman, 901 const GrGLUniformManager::UniformHandle uni, 902 const SkColor* color) { 903 uman.set4f(uni, 904 SkColorGetR(*color) / 255.f, 905 SkColorGetG(*color) / 255.f, 906 SkColorGetB(*color) / 255.f, 907 SkColorGetA(*color) / 255.f); 908} 909 910static inline void set_mul_color_uni(const GrGLUniformManager& uman, 911 const GrGLUniformManager::UniformHandle uni, 912 const SkColor* color){ 913 float a = SkColorGetA(*color) / 255.f; 914 float aDiv255 = a / 255.f; 915 uman.set4f(uni, 916 SkColorGetR(*color) * aDiv255, 917 SkColorGetG(*color) * aDiv255, 918 SkColorGetB(*color) * aDiv255, 919 a); 920} 921 922void GrGLGradientEffect::setData(const GrGLUniformManager& uman, 923 const GrDrawEffect& drawEffect) { 924 925 const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>(); 926 927 928 if (SkGradientShaderBase::kTwo_GpuColorType == e.getColorType()){ 929 930 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 931 set_mul_color_uni(uman, fColorStartUni, e.getColors(0)); 932 set_mul_color_uni(uman, fColorEndUni, e.getColors(1)); 933 } else { 934 set_color_uni(uman, fColorStartUni, e.getColors(0)); 935 set_color_uni(uman, fColorEndUni, e.getColors(1)); 936 } 937 938 } else if (SkGradientShaderBase::kThree_GpuColorType == e.getColorType()){ 939 940 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 941 set_mul_color_uni(uman, fColorStartUni, e.getColors(0)); 942 set_mul_color_uni(uman, fColorMidUni, e.getColors(1)); 943 set_mul_color_uni(uman, fColorEndUni, e.getColors(2)); 944 } else { 945 set_color_uni(uman, fColorStartUni, e.getColors(0)); 946 set_color_uni(uman, fColorMidUni, e.getColors(1)); 947 set_color_uni(uman, fColorEndUni, e.getColors(2)); 948 } 949 } else { 950 951 SkScalar yCoord = e.getYCoord(); 952 if (yCoord != fCachedYCoord) { 953 uman.set1f(fFSYUni, yCoord); 954 fCachedYCoord = yCoord; 955 } 956 } 957} 958 959 960GrGLEffect::EffectKey GrGLGradientEffect::GenBaseGradientKey(const GrDrawEffect& drawEffect) { 961 const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>(); 962 963 EffectKey key = 0; 964 965 if (SkGradientShaderBase::kTwo_GpuColorType == e.getColorType()) { 966 key |= kTwoColorKey; 967 } else if (SkGradientShaderBase::kThree_GpuColorType == e.getColorType()){ 968 key |= kThreeColorKey; 969 } 970 971 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 972 key |= kPremulBeforeInterpKey; 973 } 974 975 return key; 976} 977 978void GrGLGradientEffect::emitColor(GrGLShaderBuilder* builder, 979 const char* gradientTValue, 980 EffectKey key, 981 const char* outputColor, 982 const char* inputColor, 983 const TextureSamplerArray& samplers) { 984 if (SkGradientShaderBase::kTwo_GpuColorType == ColorTypeFromKey(key)){ 985 builder->fsCodeAppendf("\tvec4 colorTemp = mix(%s, %s, clamp(%s, 0.0, 1.0));\n", 986 builder->getUniformVariable(fColorStartUni).c_str(), 987 builder->getUniformVariable(fColorEndUni).c_str(), 988 gradientTValue); 989 // Note that we could skip this step if both colors are known to be opaque. Two 990 // considerations: 991 // The gradient SkShader reporting opaque is more restrictive than necessary in the two pt 992 // case. Make sure the key reflects this optimization (and note that it can use the same 993 // shader as thekBeforeIterp case). This same optimization applies to the 3 color case below. 994 if (GrGradientEffect::kAfterInterp_PremulType == PremulTypeFromKey(key)) { 995 builder->fsCodeAppend("\tcolorTemp.rgb *= colorTemp.a;\n"); 996 } 997 998 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, 999 (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str()); 1000 } else if (SkGradientShaderBase::kThree_GpuColorType == ColorTypeFromKey(key)){ 1001 builder->fsCodeAppendf("\tfloat oneMinus2t = 1.0 - (2.0 * (%s));\n", 1002 gradientTValue); 1003 builder->fsCodeAppendf("\tvec4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s;\n", 1004 builder->getUniformVariable(fColorStartUni).c_str()); 1005 if (kTegra3_GrGLRenderer == builder->ctxInfo().renderer()) { 1006 // The Tegra3 compiler will sometimes never return if we have 1007 // min(abs(oneMinus2t), 1.0), or do the abs first in a separate expression. 1008 builder->fsCodeAppend("\tfloat minAbs = abs(oneMinus2t);\n"); 1009 builder->fsCodeAppend("\tminAbs = minAbs > 1.0 ? 1.0 : minAbs;\n"); 1010 builder->fsCodeAppendf("\tcolorTemp += (1.0 - minAbs) * %s;\n", 1011 builder->getUniformVariable(fColorMidUni).c_str()); 1012 } else { 1013 builder->fsCodeAppendf("\tcolorTemp += (1.0 - min(abs(oneMinus2t), 1.0)) * %s;\n", 1014 builder->getUniformVariable(fColorMidUni).c_str()); 1015 } 1016 builder->fsCodeAppendf("\tcolorTemp += clamp(-oneMinus2t, 0.0, 1.0) * %s;\n", 1017 builder->getUniformVariable(fColorEndUni).c_str()); 1018 if (GrGradientEffect::kAfterInterp_PremulType == PremulTypeFromKey(key)) { 1019 builder->fsCodeAppend("\tcolorTemp.rgb *= colorTemp.a;\n"); 1020 } 1021 1022 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, 1023 (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str()); 1024 } else { 1025 builder->fsCodeAppendf("\tvec2 coord = vec2(%s, %s);\n", 1026 gradientTValue, 1027 builder->getUniformVariable(fFSYUni).c_str()); 1028 builder->fsCodeAppendf("\t%s = ", outputColor); 1029 builder->fsAppendTextureLookupAndModulate(inputColor, 1030 samplers[0], 1031 "coord"); 1032 builder->fsCodeAppend(";\n"); 1033 } 1034} 1035 1036///////////////////////////////////////////////////////////////////// 1037 1038GrGradientEffect::GrGradientEffect(GrContext* ctx, 1039 const SkGradientShaderBase& shader, 1040 const SkMatrix& matrix, 1041 SkShader::TileMode tileMode) { 1042 1043 fIsOpaque = shader.isOpaque(); 1044 1045 fColorType = shader.getGpuColorType(&fColors[0]); 1046 1047 // The two and three color specializations do not currently support tiling. 1048 if (SkGradientShaderBase::kTwo_GpuColorType == fColorType || 1049 SkGradientShaderBase::kThree_GpuColorType == fColorType) { 1050 fRow = -1; 1051 1052 if (SkGradientShader::kInterpolateColorsInPremul_Flag & shader.getGradFlags()) { 1053 fPremulType = kBeforeInterp_PremulType; 1054 } else { 1055 fPremulType = kAfterInterp_PremulType; 1056 } 1057 fCoordTransform.reset(kCoordSet, matrix); 1058 } else { 1059 // doesn't matter how this is set, just be consistent because it is part of the effect key. 1060 fPremulType = kBeforeInterp_PremulType; 1061 SkBitmap bitmap; 1062 shader.getGradientTableBitmap(&bitmap); 1063 1064 GrTextureStripAtlas::Desc desc; 1065 desc.fWidth = bitmap.width(); 1066 desc.fHeight = 32; 1067 desc.fRowHeight = bitmap.height(); 1068 desc.fContext = ctx; 1069 desc.fConfig = SkImageInfo2GrPixelConfig(bitmap.info()); 1070 fAtlas = GrTextureStripAtlas::GetAtlas(desc); 1071 SkASSERT(NULL != fAtlas); 1072 1073 // We always filter the gradient table. Each table is one row of a texture, always y-clamp. 1074 GrTextureParams params; 1075 params.setFilterMode(GrTextureParams::kBilerp_FilterMode); 1076 params.setTileModeX(tileMode); 1077 1078 fRow = fAtlas->lockRow(bitmap); 1079 if (-1 != fRow) { 1080 fYCoord = fAtlas->getYOffset(fRow) + SK_ScalarHalf * 1081 fAtlas->getVerticalScaleFactor(); 1082 fCoordTransform.reset(kCoordSet, matrix, fAtlas->getTexture()); 1083 fTextureAccess.reset(fAtlas->getTexture(), params); 1084 } else { 1085 GrTexture* texture = GrLockAndRefCachedBitmapTexture(ctx, bitmap, ¶ms); 1086 fCoordTransform.reset(kCoordSet, matrix, texture); 1087 fTextureAccess.reset(texture, params); 1088 fYCoord = SK_ScalarHalf; 1089 1090 // Unlock immediately, this is not great, but we don't have a way of 1091 // knowing when else to unlock it currently, so it may get purged from 1092 // the cache, but it'll still be ref'd until it's no longer being used. 1093 GrUnlockAndUnrefCachedBitmapTexture(texture); 1094 } 1095 this->addTextureAccess(&fTextureAccess); 1096 } 1097 this->addCoordTransform(&fCoordTransform); 1098} 1099 1100GrGradientEffect::~GrGradientEffect() { 1101 if (this->useAtlas()) { 1102 fAtlas->unlockRow(fRow); 1103 } 1104} 1105 1106bool GrGradientEffect::onIsEqual(const GrEffect& effect) const { 1107 const GrGradientEffect& s = CastEffect<GrGradientEffect>(effect); 1108 1109 if (this->fColorType == s.getColorType()){ 1110 1111 if (SkGradientShaderBase::kTwo_GpuColorType == fColorType) { 1112 if (*this->getColors(0) != *s.getColors(0) || 1113 *this->getColors(1) != *s.getColors(1)) { 1114 return false; 1115 } 1116 } else if (SkGradientShaderBase::kThree_GpuColorType == fColorType) { 1117 if (*this->getColors(0) != *s.getColors(0) || 1118 *this->getColors(1) != *s.getColors(1) || 1119 *this->getColors(2) != *s.getColors(2)) { 1120 return false; 1121 } 1122 } else { 1123 if (fYCoord != s.getYCoord()) { 1124 return false; 1125 } 1126 } 1127 1128 return fTextureAccess.getTexture() == s.fTextureAccess.getTexture() && 1129 fTextureAccess.getParams().getTileModeX() == 1130 s.fTextureAccess.getParams().getTileModeX() && 1131 this->useAtlas() == s.useAtlas() && 1132 fCoordTransform.getMatrix().cheapEqualTo(s.fCoordTransform.getMatrix()); 1133 } 1134 1135 return false; 1136} 1137 1138void GrGradientEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const { 1139 if (fIsOpaque && (kA_GrColorComponentFlag & *validFlags) && 0xff == GrColorUnpackA(*color)) { 1140 *validFlags = kA_GrColorComponentFlag; 1141 } else { 1142 *validFlags = 0; 1143 } 1144} 1145 1146int GrGradientEffect::RandomGradientParams(SkRandom* random, 1147 SkColor colors[], 1148 SkScalar** stops, 1149 SkShader::TileMode* tm) { 1150 int outColors = random->nextRangeU(1, kMaxRandomGradientColors); 1151 1152 // if one color, omit stops, otherwise randomly decide whether or not to 1153 if (outColors == 1 || (outColors >= 2 && random->nextBool())) { 1154 *stops = NULL; 1155 } 1156 1157 SkScalar stop = 0.f; 1158 for (int i = 0; i < outColors; ++i) { 1159 colors[i] = random->nextU(); 1160 if (NULL != *stops) { 1161 (*stops)[i] = stop; 1162 stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f; 1163 } 1164 } 1165 *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount)); 1166 1167 return outColors; 1168} 1169 1170#endif 1171