SkRadialGradient.cpp revision 396e61fe440590744345e0c56970b26ab464591d
1 2/* 3 * Copyright 2012 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9#include "SkRadialGradient.h" 10#include "SkRadialGradient_Table.h" 11 12#define kSQRT_TABLE_BITS 11 13#define kSQRT_TABLE_SIZE (1 << kSQRT_TABLE_BITS) 14 15#if defined(SK_BUILD_FOR_WIN32) && defined(SK_DEBUG) 16 17#include <stdio.h> 18 19void SkRadialGradient_BuildTable() { 20 // build it 0..127 x 0..127, so we use 2^15 - 1 in the numerator for our "fixed" table 21 22 FILE* file = ::fopen("SkRadialGradient_Table.h", "w"); 23 SkASSERT(file); 24 ::fprintf(file, "static const uint8_t gSqrt8Table[] = {\n"); 25 26 for (int i = 0; i < kSQRT_TABLE_SIZE; i++) { 27 if ((i & 15) == 0) { 28 ::fprintf(file, "\t"); 29 } 30 31 uint8_t value = SkToU8(SkFixedSqrt(i * SK_Fixed1 / kSQRT_TABLE_SIZE) >> 8); 32 33 ::fprintf(file, "0x%02X", value); 34 if (i < kSQRT_TABLE_SIZE-1) { 35 ::fprintf(file, ", "); 36 } 37 if ((i & 15) == 15) { 38 ::fprintf(file, "\n"); 39 } 40 } 41 ::fprintf(file, "};\n"); 42 ::fclose(file); 43} 44 45#endif 46 47namespace { 48 49void rad_to_unit_matrix(const SkPoint& center, SkScalar radius, 50 SkMatrix* matrix) { 51 SkScalar inv = SkScalarInvert(radius); 52 53 matrix->setTranslate(-center.fX, -center.fY); 54 matrix->postScale(inv, inv); 55} 56 57typedef void (* RadialShade16Proc)(SkScalar sfx, SkScalar sdx, 58 SkScalar sfy, SkScalar sdy, 59 uint16_t* dstC, const uint16_t* cache, 60 int toggle, int count); 61 62void shadeSpan16_radial_clamp(SkScalar sfx, SkScalar sdx, 63 SkScalar sfy, SkScalar sdy, 64 uint16_t* SK_RESTRICT dstC, const uint16_t* SK_RESTRICT cache, 65 int toggle, int count) { 66 const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table; 67 68 /* knock these down so we can pin against +- 0x7FFF, which is an 69 immediate load, rather than 0xFFFF which is slower. This is a 70 compromise, since it reduces our precision, but that appears 71 to be visually OK. If we decide this is OK for all of our cases, 72 we could (it seems) put this scale-down into fDstToIndex, 73 to avoid having to do these extra shifts each time. 74 */ 75 SkFixed fx = SkScalarToFixed(sfx) >> 1; 76 SkFixed dx = SkScalarToFixed(sdx) >> 1; 77 SkFixed fy = SkScalarToFixed(sfy) >> 1; 78 SkFixed dy = SkScalarToFixed(sdy) >> 1; 79 // might perform this check for the other modes, 80 // but the win will be a smaller % of the total 81 if (dy == 0) { 82 fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1); 83 fy *= fy; 84 do { 85 unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1); 86 unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS); 87 fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS)); 88 fx += dx; 89 *dstC++ = cache[toggle + 90 (sqrt_table[fi] >> SkGradientShaderBase::kSqrt16Shift)]; 91 toggle ^= SkGradientShaderBase::kDitherStride16; 92 } while (--count != 0); 93 } else { 94 do { 95 unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1); 96 unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1); 97 fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS); 98 fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS)); 99 fx += dx; 100 fy += dy; 101 *dstC++ = cache[toggle + 102 (sqrt_table[fi] >> SkGradientShaderBase::kSqrt16Shift)]; 103 toggle ^= SkGradientShaderBase::kDitherStride16; 104 } while (--count != 0); 105 } 106} 107 108void shadeSpan16_radial_mirror(SkScalar sfx, SkScalar sdx, 109 SkScalar sfy, SkScalar sdy, 110 uint16_t* SK_RESTRICT dstC, const uint16_t* SK_RESTRICT cache, 111 int toggle, int count) { 112 do { 113#ifdef SK_SCALAR_IS_FLOAT 114 float fdist = sk_float_sqrt(sfx*sfx + sfy*sfy); 115 SkFixed dist = SkFloatToFixed(fdist); 116#else 117 SkFixed magnitudeSquared = SkFixedSquare(sfx) + 118 SkFixedSquare(sfy); 119 if (magnitudeSquared < 0) // Overflow. 120 magnitudeSquared = SK_FixedMax; 121 SkFixed dist = SkFixedSqrt(magnitudeSquared); 122#endif 123 unsigned fi = mirror_tileproc(dist); 124 SkASSERT(fi <= 0xFFFF); 125 *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache16Shift)]; 126 toggle ^= SkGradientShaderBase::kDitherStride16; 127 sfx += sdx; 128 sfy += sdy; 129 } while (--count != 0); 130} 131 132void shadeSpan16_radial_repeat(SkScalar sfx, SkScalar sdx, 133 SkScalar sfy, SkScalar sdy, 134 uint16_t* SK_RESTRICT dstC, const uint16_t* SK_RESTRICT cache, 135 int toggle, int count) { 136 SkFixed fx = SkScalarToFixed(sfx); 137 SkFixed dx = SkScalarToFixed(sdx); 138 SkFixed fy = SkScalarToFixed(sfy); 139 SkFixed dy = SkScalarToFixed(sdy); 140 do { 141 SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy)); 142 unsigned fi = repeat_tileproc(dist); 143 SkASSERT(fi <= 0xFFFF); 144 fx += dx; 145 fy += dy; 146 *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache16Shift)]; 147 toggle ^= SkGradientShaderBase::kDitherStride16; 148 } while (--count != 0); 149} 150 151} 152 153///////////////////////////////////////////////////////////////////// 154 155SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius, 156 const SkColor colors[], const SkScalar pos[], int colorCount, 157 SkShader::TileMode mode, SkUnitMapper* mapper) 158 : SkGradientShaderBase(colors, pos, colorCount, mode, mapper), 159 fCenter(center), 160 fRadius(radius) 161{ 162 // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE 163 SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE); 164 165 rad_to_unit_matrix(center, radius, &fPtsToUnit); 166} 167 168void SkRadialGradient::shadeSpan16(int x, int y, uint16_t* dstCParam, 169 int count) { 170 SkASSERT(count > 0); 171 172 uint16_t* SK_RESTRICT dstC = dstCParam; 173 174 SkPoint srcPt; 175 SkMatrix::MapXYProc dstProc = fDstToIndexProc; 176 TileProc proc = fTileProc; 177 const uint16_t* SK_RESTRICT cache = this->getCache16(); 178 int toggle = ((x ^ y) & 1) * kDitherStride16; 179 180 if (fDstToIndexClass != kPerspective_MatrixClass) { 181 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf, 182 SkIntToScalar(y) + SK_ScalarHalf, &srcPt); 183 184 SkScalar sdx = fDstToIndex.getScaleX(); 185 SkScalar sdy = fDstToIndex.getSkewY(); 186 187 if (fDstToIndexClass == kFixedStepInX_MatrixClass) { 188 SkFixed storage[2]; 189 (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), 190 &storage[0], &storage[1]); 191 sdx = SkFixedToScalar(storage[0]); 192 sdy = SkFixedToScalar(storage[1]); 193 } else { 194 SkASSERT(fDstToIndexClass == kLinear_MatrixClass); 195 } 196 197 RadialShade16Proc shadeProc = shadeSpan16_radial_repeat; 198 if (SkShader::kClamp_TileMode == fTileMode) { 199 shadeProc = shadeSpan16_radial_clamp; 200 } else if (SkShader::kMirror_TileMode == fTileMode) { 201 shadeProc = shadeSpan16_radial_mirror; 202 } else { 203 SkASSERT(SkShader::kRepeat_TileMode == fTileMode); 204 } 205 (*shadeProc)(srcPt.fX, sdx, srcPt.fY, sdy, dstC, 206 cache, toggle, count); 207 } else { // perspective case 208 SkScalar dstX = SkIntToScalar(x); 209 SkScalar dstY = SkIntToScalar(y); 210 do { 211 dstProc(fDstToIndex, dstX, dstY, &srcPt); 212 unsigned fi = proc(SkScalarToFixed(srcPt.length())); 213 SkASSERT(fi <= 0xFFFF); 214 215 int index = fi >> (16 - kCache16Bits); 216 *dstC++ = cache[toggle + index]; 217 toggle ^= kDitherStride16; 218 219 dstX += SK_Scalar1; 220 } while (--count != 0); 221 } 222} 223 224SkShader::BitmapType SkRadialGradient::asABitmap(SkBitmap* bitmap, 225 SkMatrix* matrix, SkShader::TileMode* xy) const { 226 if (bitmap) { 227 this->getGradientTableBitmap(bitmap); 228 } 229 if (matrix) { 230 matrix->setScale(SkIntToScalar(kGradient32Length), 231 SkIntToScalar(kGradient32Length)); 232 matrix->preConcat(fPtsToUnit); 233 } 234 if (xy) { 235 xy[0] = fTileMode; 236 xy[1] = kClamp_TileMode; 237 } 238 return kRadial_BitmapType; 239} 240 241SkShader::GradientType SkRadialGradient::asAGradient(GradientInfo* info) const { 242 if (info) { 243 commonAsAGradient(info); 244 info->fPoint[0] = fCenter; 245 info->fRadius[0] = fRadius; 246 } 247 return kRadial_GradientType; 248} 249 250SkRadialGradient::SkRadialGradient(SkFlattenableReadBuffer& buffer) 251 : INHERITED(buffer), 252 fCenter(buffer.readPoint()), 253 fRadius(buffer.readScalar()) { 254} 255 256void SkRadialGradient::flatten(SkFlattenableWriteBuffer& buffer) const { 257 this->INHERITED::flatten(buffer); 258 buffer.writePoint(fCenter); 259 buffer.writeScalar(fRadius); 260} 261 262namespace { 263 264inline bool radial_completely_pinned(int fx, int dx, int fy, int dy) { 265 // fast, overly-conservative test: checks unit square instead 266 // of unit circle 267 bool xClamped = (fx >= SK_FixedHalf && dx >= 0) || 268 (fx <= -SK_FixedHalf && dx <= 0); 269 bool yClamped = (fy >= SK_FixedHalf && dy >= 0) || 270 (fy <= -SK_FixedHalf && dy <= 0); 271 272 return xClamped || yClamped; 273} 274 275// Return true if (fx * fy) is always inside the unit circle 276// SkPin32 is expensive, but so are all the SkFixedMul in this test, 277// so it shouldn't be run if count is small. 278inline bool no_need_for_radial_pin(int fx, int dx, 279 int fy, int dy, int count) { 280 SkASSERT(count > 0); 281 if (SkAbs32(fx) > 0x7FFF || SkAbs32(fy) > 0x7FFF) { 282 return false; 283 } 284 if (fx*fx + fy*fy > 0x7FFF*0x7FFF) { 285 return false; 286 } 287 fx += (count - 1) * dx; 288 fy += (count - 1) * dy; 289 if (SkAbs32(fx) > 0x7FFF || SkAbs32(fy) > 0x7FFF) { 290 return false; 291 } 292 return fx*fx + fy*fy <= 0x7FFF*0x7FFF; 293} 294 295#define UNPINNED_RADIAL_STEP \ 296 fi = (fx * fx + fy * fy) >> (14 + 16 - kSQRT_TABLE_BITS); \ 297 *dstC++ = cache[toggle + \ 298 (sqrt_table[fi] >> SkGradientShaderBase::kSqrt32Shift)]; \ 299 toggle ^= SkGradientShaderBase::kDitherStride32; \ 300 fx += dx; \ 301 fy += dy; 302 303typedef void (* RadialShadeProc)(SkScalar sfx, SkScalar sdx, 304 SkScalar sfy, SkScalar sdy, 305 SkPMColor* dstC, const SkPMColor* cache, 306 int count, int toggle); 307 308// On Linux, this is faster with SkPMColor[] params than SkPMColor* SK_RESTRICT 309void shadeSpan_radial_clamp(SkScalar sfx, SkScalar sdx, 310 SkScalar sfy, SkScalar sdy, 311 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 312 int count, int toggle) { 313 // Floating point seems to be slower than fixed point, 314 // even when we have float hardware. 315 const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table; 316 SkFixed fx = SkScalarToFixed(sfx) >> 1; 317 SkFixed dx = SkScalarToFixed(sdx) >> 1; 318 SkFixed fy = SkScalarToFixed(sfy) >> 1; 319 SkFixed dy = SkScalarToFixed(sdy) >> 1; 320 if ((count > 4) && radial_completely_pinned(fx, dx, fy, dy)) { 321 unsigned fi = SkGradientShaderBase::kGradient32Length; 322 sk_memset32_dither(dstC, 323 cache[toggle + fi], 324 cache[(toggle ^ SkGradientShaderBase::kDitherStride32) + fi], 325 count); 326 } else if ((count > 4) && 327 no_need_for_radial_pin(fx, dx, fy, dy, count)) { 328 unsigned fi; 329 // 4x unroll appears to be no faster than 2x unroll on Linux 330 while (count > 1) { 331 UNPINNED_RADIAL_STEP; 332 UNPINNED_RADIAL_STEP; 333 count -= 2; 334 } 335 if (count) { 336 UNPINNED_RADIAL_STEP; 337 } 338 } 339 else { 340 // Specializing for dy == 0 gains us 25% on Skia benchmarks 341 if (dy == 0) { 342 unsigned yy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1); 343 yy *= yy; 344 do { 345 unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1); 346 unsigned fi = (xx * xx + yy) >> (14 + 16 - kSQRT_TABLE_BITS); 347 fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS)); 348 *dstC++ = cache[toggle + (sqrt_table[fi] >> 349 SkGradientShaderBase::kSqrt32Shift)]; 350 toggle ^= SkGradientShaderBase::kDitherStride32; 351 fx += dx; 352 } while (--count != 0); 353 } else { 354 do { 355 unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1); 356 unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1); 357 fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS); 358 fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS)); 359 *dstC++ = cache[toggle + (sqrt_table[fi] >> 360 SkGradientShaderBase::kSqrt32Shift)]; 361 toggle ^= SkGradientShaderBase::kDitherStride32; 362 fx += dx; 363 fy += dy; 364 } while (--count != 0); 365 } 366 } 367} 368 369// Unrolling this loop doesn't seem to help (when float); we're stalling to 370// get the results of the sqrt (?), and don't have enough extra registers to 371// have many in flight. 372void shadeSpan_radial_mirror(SkScalar sfx, SkScalar sdx, 373 SkScalar sfy, SkScalar sdy, 374 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 375 int count, int toggle) { 376 do { 377#ifdef SK_SCALAR_IS_FLOAT 378 float fdist = sk_float_sqrt(sfx*sfx + sfy*sfy); 379 SkFixed dist = SkFloatToFixed(fdist); 380#else 381 SkFixed magnitudeSquared = SkFixedSquare(sfx) + 382 SkFixedSquare(sfy); 383 if (magnitudeSquared < 0) // Overflow. 384 magnitudeSquared = SK_FixedMax; 385 SkFixed dist = SkFixedSqrt(magnitudeSquared); 386#endif 387 unsigned fi = mirror_tileproc(dist); 388 SkASSERT(fi <= 0xFFFF); 389 *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache32Shift)]; 390 toggle ^= SkGradientShaderBase::kDitherStride32; 391 sfx += sdx; 392 sfy += sdy; 393 } while (--count != 0); 394} 395 396void shadeSpan_radial_repeat(SkScalar sfx, SkScalar sdx, 397 SkScalar sfy, SkScalar sdy, 398 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 399 int count, int toggle) { 400 SkFixed fx = SkScalarToFixed(sfx); 401 SkFixed dx = SkScalarToFixed(sdx); 402 SkFixed fy = SkScalarToFixed(sfy); 403 SkFixed dy = SkScalarToFixed(sdy); 404 do { 405 SkFixed magnitudeSquared = SkFixedSquare(fx) + 406 SkFixedSquare(fy); 407 if (magnitudeSquared < 0) // Overflow. 408 magnitudeSquared = SK_FixedMax; 409 SkFixed dist = SkFixedSqrt(magnitudeSquared); 410 unsigned fi = repeat_tileproc(dist); 411 SkASSERT(fi <= 0xFFFF); 412 *dstC++ = cache[toggle + (fi >> SkGradientShaderBase::kCache32Shift)]; 413 toggle ^= SkGradientShaderBase::kDitherStride32; 414 fx += dx; 415 fy += dy; 416 } while (--count != 0); 417} 418} 419 420void SkRadialGradient::shadeSpan(int x, int y, 421 SkPMColor* SK_RESTRICT dstC, int count) { 422 SkASSERT(count > 0); 423 424 SkPoint srcPt; 425 SkMatrix::MapXYProc dstProc = fDstToIndexProc; 426 TileProc proc = fTileProc; 427 const SkPMColor* SK_RESTRICT cache = this->getCache32(); 428#ifdef USE_DITHER_32BIT_GRADIENT 429 int toggle = ((x ^ y) & 1) * SkGradientShaderBase::kDitherStride32; 430#else 431 int toggle = 0; 432#endif 433 434 if (fDstToIndexClass != kPerspective_MatrixClass) { 435 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf, 436 SkIntToScalar(y) + SK_ScalarHalf, &srcPt); 437 SkScalar sdx = fDstToIndex.getScaleX(); 438 SkScalar sdy = fDstToIndex.getSkewY(); 439 440 if (fDstToIndexClass == kFixedStepInX_MatrixClass) { 441 SkFixed storage[2]; 442 (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), 443 &storage[0], &storage[1]); 444 sdx = SkFixedToScalar(storage[0]); 445 sdy = SkFixedToScalar(storage[1]); 446 } else { 447 SkASSERT(fDstToIndexClass == kLinear_MatrixClass); 448 } 449 450 RadialShadeProc shadeProc = shadeSpan_radial_repeat; 451 if (SkShader::kClamp_TileMode == fTileMode) { 452 shadeProc = shadeSpan_radial_clamp; 453 } else if (SkShader::kMirror_TileMode == fTileMode) { 454 shadeProc = shadeSpan_radial_mirror; 455 } else { 456 SkASSERT(SkShader::kRepeat_TileMode == fTileMode); 457 } 458 (*shadeProc)(srcPt.fX, sdx, srcPt.fY, sdy, dstC, cache, count, toggle); 459 } else { // perspective case 460 SkScalar dstX = SkIntToScalar(x); 461 SkScalar dstY = SkIntToScalar(y); 462 do { 463 dstProc(fDstToIndex, dstX, dstY, &srcPt); 464 unsigned fi = proc(SkScalarToFixed(srcPt.length())); 465 SkASSERT(fi <= 0xFFFF); 466 *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift]; 467 dstX += SK_Scalar1; 468 } while (--count != 0); 469 } 470} 471 472///////////////////////////////////////////////////////////////////// 473 474#if SK_SUPPORT_GPU 475 476class GrGLRadialGradient : public GrGLGradientStage { 477public: 478 479 GrGLRadialGradient(const GrBackendEffectFactory& factory, 480 const GrEffect&) : INHERITED (factory) { } 481 virtual ~GrGLRadialGradient() { } 482 483 virtual void emitVS(GrGLShaderBuilder* builder, 484 const char* vertexCoords) SK_OVERRIDE { } 485 virtual void emitFS(GrGLShaderBuilder* builder, 486 const char* outputColor, 487 const char* inputColor, 488 const TextureSamplerArray&) SK_OVERRIDE; 489 490 static StageKey GenKey(const GrEffect& s, const GrGLCaps& caps) { return 0; } 491 492private: 493 494 typedef GrGLGradientStage INHERITED; 495 496}; 497 498///////////////////////////////////////////////////////////////////// 499 500class GrRadialGradient : public GrGradientEffect { 501public: 502 503 GrRadialGradient(GrContext* ctx, const SkRadialGradient& shader, SkShader::TileMode tm) 504 : INHERITED(ctx, shader, tm) { 505 } 506 507 virtual ~GrRadialGradient() { } 508 509 static const char* Name() { return "Radial Gradient"; } 510 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { 511 return GrTBackendEffectFactory<GrRadialGradient>::getInstance(); 512 } 513 514 typedef GrGLRadialGradient GLEffect; 515 516private: 517 GR_DECLARE_EFFECT_TEST; 518 519 typedef GrGradientEffect INHERITED; 520}; 521 522///////////////////////////////////////////////////////////////////// 523 524GR_DEFINE_EFFECT_TEST(GrRadialGradient); 525 526GrEffect* GrRadialGradient::TestCreate(SkRandom* random, 527 GrContext* context, 528 GrTexture**) { 529 SkPoint center = {random->nextUScalar1(), random->nextUScalar1()}; 530 SkScalar radius = random->nextUScalar1(); 531 532 SkColor colors[kMaxRandomGradientColors]; 533 SkScalar stopsArray[kMaxRandomGradientColors]; 534 SkScalar* stops = stopsArray; 535 SkShader::TileMode tm; 536 int colorCount = RandomGradientParams(random, colors, &stops, &tm); 537 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, 538 colors, stops, colorCount, 539 tm)); 540 GrSamplerState sampler; 541 shader->asNewEffect(context, &sampler); 542 GrAssert(NULL != sampler.getEffect()); 543 // const_cast and ref is a hack! Will remove when asNewEffect returns GrEffect* 544 sampler.getEffect()->ref(); 545 return const_cast<GrEffect*>(sampler.getEffect()); 546} 547 548///////////////////////////////////////////////////////////////////// 549 550void GrGLRadialGradient::emitFS(GrGLShaderBuilder* builder, 551 const char* outputColor, 552 const char* inputColor, 553 const TextureSamplerArray& samplers) { 554 SkString t; 555 t.printf("length(%s.xy)", builder->defaultTexCoordsName()); 556 this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplers[0]); 557} 558 559///////////////////////////////////////////////////////////////////// 560 561bool SkRadialGradient::asNewEffect(GrContext* context, GrSamplerState* sampler) const { 562 SkASSERT(NULL != context && NULL != sampler); 563 SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrRadialGradient, (context, *this, fTileMode))); 564 565 SkMatrix matrix; 566 if (this->getLocalMatrix(&matrix)) { 567 if (!matrix.invert(&matrix)) { 568 return false; 569 } 570 matrix.postConcat(fPtsToUnit); 571 sampler->setEffect(effect, matrix); 572 } else { 573 sampler->setEffect(effect, fPtsToUnit); 574 } 575 576 return true; 577} 578 579#else 580 581bool SkRadialGradient::asNewEffect(GrContext*, GrSamplerState*) const { 582 SkDEBUGFAIL("Should not call in GPU-less build"); 583 return false; 584} 585 586#endif 587