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