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