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 "SkTwoPointRadialGradient.h" 10 11 /* Two-point radial gradients are specified by two circles, each with a center 12 point and radius. The gradient can be considered to be a series of 13 concentric circles, with the color interpolated from the start circle 14 (at t=0) to the end circle (at t=1). 15 16 For each point (x, y) in the span, we want to find the 17 interpolated circle that intersects that point. The center 18 of the desired circle (Cx, Cy) falls at some distance t 19 along the line segment between the start point (Sx, Sy) and 20 end point (Ex, Ey): 21 22 Cx = (1 - t) * Sx + t * Ex (0 <= t <= 1) 23 Cy = (1 - t) * Sy + t * Ey 24 25 The radius of the desired circle (r) is also a linear interpolation t 26 between the start and end radii (Sr and Er): 27 28 r = (1 - t) * Sr + t * Er 29 30 But 31 32 (x - Cx)^2 + (y - Cy)^2 = r^2 33 34 so 35 36 (x - ((1 - t) * Sx + t * Ex))^2 37 + (y - ((1 - t) * Sy + t * Ey))^2 38 = ((1 - t) * Sr + t * Er)^2 39 40 Solving for t yields 41 42 [(Sx - Ex)^2 + (Sy - Ey)^2 - (Er - Sr)^2)] * t^2 43 + [2 * (Sx - Ex)(x - Sx) + 2 * (Sy - Ey)(y - Sy) - 2 * (Er - Sr) * Sr] * t 44 + [(x - Sx)^2 + (y - Sy)^2 - Sr^2] = 0 45 46 To simplify, let Dx = Sx - Ex, Dy = Sy - Ey, Dr = Er - Sr, dx = x - Sx, dy = y - Sy 47 48 [Dx^2 + Dy^2 - Dr^2)] * t^2 49 + 2 * [Dx * dx + Dy * dy - Dr * Sr] * t 50 + [dx^2 + dy^2 - Sr^2] = 0 51 52 A quadratic in t. The two roots of the quadratic reflect the two 53 possible circles on which the point may fall. Solving for t yields 54 the gradient value to use. 55 56 If a<0, the start circle is entirely contained in the 57 end circle, and one of the roots will be <0 or >1 (off the line 58 segment). If a>0, the start circle falls at least partially 59 outside the end circle (or vice versa), and the gradient 60 defines a "tube" where a point may be on one circle (on the 61 inside of the tube) or the other (outside of the tube). We choose 62 one arbitrarily. 63 64 In order to keep the math to within the limits of fixed point, 65 we divide the entire quadratic by Dr^2, and replace 66 (x - Sx)/Dr with x' and (y - Sy)/Dr with y', giving 67 68 [Dx^2 / Dr^2 + Dy^2 / Dr^2 - 1)] * t^2 69 + 2 * [x' * Dx / Dr + y' * Dy / Dr - Sr / Dr] * t 70 + [x'^2 + y'^2 - Sr^2/Dr^2] = 0 71 72 (x' and y' are computed by appending the subtract and scale to the 73 fDstToIndex matrix in the constructor). 74 75 Since the 'A' component of the quadratic is independent of x' and y', it 76 is precomputed in the constructor. Since the 'B' component is linear in 77 x' and y', if x and y are linear in the span, 'B' can be computed 78 incrementally with a simple delta (db below). If it is not (e.g., 79 a perspective projection), it must be computed in the loop. 80 81 */ 82 83 namespace { 84 85 inline SkFixed two_point_radial(SkScalar b, SkScalar fx, SkScalar fy, 86 SkScalar sr2d2, SkScalar foura, 87 SkScalar oneOverTwoA, bool posRoot) { 88 SkScalar c = SkScalarSquare(fx) + SkScalarSquare(fy) - sr2d2; 89 if (0 == foura) { 90 return SkScalarToFixed(SkScalarDiv(-c, b)); 91 } 92 93 SkScalar discrim = SkScalarSquare(b) - SkScalarMul(foura, c); 94 if (discrim < 0) { 95 discrim = -discrim; 96 } 97 SkScalar rootDiscrim = SkScalarSqrt(discrim); 98 SkScalar result; 99 if (posRoot) { 100 result = SkScalarMul(-b + rootDiscrim, oneOverTwoA); 101 } else { 102 result = SkScalarMul(-b - rootDiscrim, oneOverTwoA); 103 } 104 return SkScalarToFixed(result); 105 } 106 107 typedef void (* TwoPointRadialShadeProc)(SkScalar fx, SkScalar dx, 108 SkScalar fy, SkScalar dy, 109 SkScalar b, SkScalar db, 110 SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, 111 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 112 int count); 113 114 void shadeSpan_twopoint_clamp(SkScalar fx, SkScalar dx, 115 SkScalar fy, SkScalar dy, 116 SkScalar b, SkScalar db, 117 SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, 118 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 119 int count) { 120 for (; count > 0; --count) { 121 SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, 122 fOneOverTwoA, posRoot); 123 SkFixed index = SkClampMax(t, 0xFFFF); 124 SkASSERT(index <= 0xFFFF); 125 *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; 126 fx += dx; 127 fy += dy; 128 b += db; 129 } 130 } 131 void shadeSpan_twopoint_mirror(SkScalar fx, SkScalar dx, 132 SkScalar fy, SkScalar dy, 133 SkScalar b, SkScalar db, 134 SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, 135 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 136 int count) { 137 for (; count > 0; --count) { 138 SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, 139 fOneOverTwoA, posRoot); 140 SkFixed index = mirror_tileproc(t); 141 SkASSERT(index <= 0xFFFF); 142 *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; 143 fx += dx; 144 fy += dy; 145 b += db; 146 } 147 } 148 149 void shadeSpan_twopoint_repeat(SkScalar fx, SkScalar dx, 150 SkScalar fy, SkScalar dy, 151 SkScalar b, SkScalar db, 152 SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot, 153 SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache, 154 int count) { 155 for (; count > 0; --count) { 156 SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, 157 fOneOverTwoA, posRoot); 158 SkFixed index = repeat_tileproc(t); 159 SkASSERT(index <= 0xFFFF); 160 *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; 161 fx += dx; 162 fy += dy; 163 b += db; 164 } 165 } 166 } 167 168 ///////////////////////////////////////////////////////////////////// 169 170 SkTwoPointRadialGradient::SkTwoPointRadialGradient( 171 const SkPoint& start, SkScalar startRadius, 172 const SkPoint& end, SkScalar endRadius, 173 const Descriptor& desc) 174 : SkGradientShaderBase(desc), 175 fCenter1(start), 176 fCenter2(end), 177 fRadius1(startRadius), 178 fRadius2(endRadius) { 179 init(); 180 } 181 182 SkShader::BitmapType SkTwoPointRadialGradient::asABitmap( 183 SkBitmap* bitmap, 184 SkMatrix* matrix, 185 SkShader::TileMode* xy) const { 186 if (bitmap) { 187 this->getGradientTableBitmap(bitmap); 188 } 189 SkScalar diffL = 0; // just to avoid gcc warning 190 if (matrix) { 191 diffL = SkScalarSqrt(SkScalarSquare(fDiff.fX) + 192 SkScalarSquare(fDiff.fY)); 193 } 194 if (matrix) { 195 if (diffL) { 196 SkScalar invDiffL = SkScalarInvert(diffL); 197 matrix->setSinCos(-SkScalarMul(invDiffL, fDiff.fY), 198 SkScalarMul(invDiffL, fDiff.fX)); 199 } else { 200 matrix->reset(); 201 } 202 matrix->preConcat(fPtsToUnit); 203 } 204 if (xy) { 205 xy[0] = fTileMode; 206 xy[1] = kClamp_TileMode; 207 } 208 return kTwoPointRadial_BitmapType; 209 } 210 211 SkShader::GradientType SkTwoPointRadialGradient::asAGradient( 212 SkShader::GradientInfo* info) const { 213 if (info) { 214 commonAsAGradient(info); 215 info->fPoint[0] = fCenter1; 216 info->fPoint[1] = fCenter2; 217 info->fRadius[0] = fRadius1; 218 info->fRadius[1] = fRadius2; 219 } 220 return kRadial2_GradientType; 221 } 222 223 void SkTwoPointRadialGradient::shadeSpan(int x, int y, SkPMColor* dstCParam, 224 int count) { 225 SkASSERT(count > 0); 226 227 SkPMColor* SK_RESTRICT dstC = dstCParam; 228 229 // Zero difference between radii: fill with transparent black. 230 if (fDiffRadius == 0) { 231 sk_bzero(dstC, count * sizeof(*dstC)); 232 return; 233 } 234 SkMatrix::MapXYProc dstProc = fDstToIndexProc; 235 TileProc proc = fTileProc; 236 const SkPMColor* SK_RESTRICT cache = this->getCache32(); 237 238 SkScalar foura = fA * 4; 239 bool posRoot = fDiffRadius < 0; 240 if (fDstToIndexClass != kPerspective_MatrixClass) { 241 SkPoint srcPt; 242 dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf, 243 SkIntToScalar(y) + SK_ScalarHalf, &srcPt); 244 SkScalar dx, fx = srcPt.fX; 245 SkScalar dy, fy = srcPt.fY; 246 247 if (fDstToIndexClass == kFixedStepInX_MatrixClass) { 248 SkFixed fixedX, fixedY; 249 (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY); 250 dx = SkFixedToScalar(fixedX); 251 dy = SkFixedToScalar(fixedY); 252 } else { 253 SkASSERT(fDstToIndexClass == kLinear_MatrixClass); 254 dx = fDstToIndex.getScaleX(); 255 dy = fDstToIndex.getSkewY(); 256 } 257 SkScalar b = (SkScalarMul(fDiff.fX, fx) + 258 SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2; 259 SkScalar db = (SkScalarMul(fDiff.fX, dx) + 260 SkScalarMul(fDiff.fY, dy)) * 2; 261 262 TwoPointRadialShadeProc shadeProc = shadeSpan_twopoint_repeat; 263 if (SkShader::kClamp_TileMode == fTileMode) { 264 shadeProc = shadeSpan_twopoint_clamp; 265 } else if (SkShader::kMirror_TileMode == fTileMode) { 266 shadeProc = shadeSpan_twopoint_mirror; 267 } else { 268 SkASSERT(SkShader::kRepeat_TileMode == fTileMode); 269 } 270 (*shadeProc)(fx, dx, fy, dy, b, db, 271 fSr2D2, foura, fOneOverTwoA, posRoot, 272 dstC, cache, count); 273 } else { // perspective case 274 SkScalar dstX = SkIntToScalar(x); 275 SkScalar dstY = SkIntToScalar(y); 276 for (; count > 0; --count) { 277 SkPoint srcPt; 278 dstProc(fDstToIndex, dstX, dstY, &srcPt); 279 SkScalar fx = srcPt.fX; 280 SkScalar fy = srcPt.fY; 281 SkScalar b = (SkScalarMul(fDiff.fX, fx) + 282 SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2; 283 SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, 284 fOneOverTwoA, posRoot); 285 SkFixed index = proc(t); 286 SkASSERT(index <= 0xFFFF); 287 *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift]; 288 dstX += SK_Scalar1; 289 } 290 } 291 } 292 293 bool SkTwoPointRadialGradient::setContext( const SkBitmap& device, 294 const SkPaint& paint, 295 const SkMatrix& matrix){ 296 // For now, we might have divided by zero, so detect that 297 if (0 == fDiffRadius) { 298 return false; 299 } 300 301 if (!this->INHERITED::setContext(device, paint, matrix)) { 302 return false; 303 } 304 305 // we don't have a span16 proc 306 fFlags &= ~kHasSpan16_Flag; 307 return true; 308 } 309 310 #ifdef SK_DEVELOPER 311 void SkTwoPointRadialGradient::toString(SkString* str) const { 312 str->append("SkTwoPointRadialGradient: ("); 313 314 str->append("center1: ("); 315 str->appendScalar(fCenter1.fX); 316 str->append(", "); 317 str->appendScalar(fCenter1.fY); 318 str->append(") radius1: "); 319 str->appendScalar(fRadius1); 320 str->append(" "); 321 322 str->append("center2: ("); 323 str->appendScalar(fCenter2.fX); 324 str->append(", "); 325 str->appendScalar(fCenter2.fY); 326 str->append(") radius2: "); 327 str->appendScalar(fRadius2); 328 str->append(" "); 329 330 this->INHERITED::toString(str); 331 332 str->append(")"); 333 } 334 #endif 335 336 SkTwoPointRadialGradient::SkTwoPointRadialGradient( 337 SkFlattenableReadBuffer& buffer) 338 : INHERITED(buffer), 339 fCenter1(buffer.readPoint()), 340 fCenter2(buffer.readPoint()), 341 fRadius1(buffer.readScalar()), 342 fRadius2(buffer.readScalar()) { 343 init(); 344 }; 345 346 void SkTwoPointRadialGradient::flatten( 347 SkFlattenableWriteBuffer& buffer) const { 348 this->INHERITED::flatten(buffer); 349 buffer.writePoint(fCenter1); 350 buffer.writePoint(fCenter2); 351 buffer.writeScalar(fRadius1); 352 buffer.writeScalar(fRadius2); 353 } 354 355 void SkTwoPointRadialGradient::init() { 356 fDiff = fCenter1 - fCenter2; 357 fDiffRadius = fRadius2 - fRadius1; 358 // hack to avoid zero-divide for now 359 SkScalar inv = fDiffRadius ? SkScalarInvert(fDiffRadius) : 0; 360 fDiff.fX = SkScalarMul(fDiff.fX, inv); 361 fDiff.fY = SkScalarMul(fDiff.fY, inv); 362 fStartRadius = SkScalarMul(fRadius1, inv); 363 fSr2D2 = SkScalarSquare(fStartRadius); 364 fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1; 365 fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0; 366 367 fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY); 368 fPtsToUnit.postScale(inv, inv); 369 } 370 371 ///////////////////////////////////////////////////////////////////// 372 373 #if SK_SUPPORT_GPU 374 375 #include "GrTBackendEffectFactory.h" 376 377 // For brevity 378 typedef GrGLUniformManager::UniformHandle UniformHandle; 379 380 class GrGLRadial2Gradient : public GrGLGradientEffect { 381 382 public: 383 384 GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&); 385 virtual ~GrGLRadial2Gradient() { } 386 387 virtual void emitCode(GrGLShaderBuilder*, 388 const GrDrawEffect&, 389 EffectKey, 390 const char* outputColor, 391 const char* inputColor, 392 const TransformedCoordsArray&, 393 const TextureSamplerArray&) SK_OVERRIDE; 394 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE; 395 396 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps); 397 398 protected: 399 400 UniformHandle fParamUni; 401 402 const char* fVSVaryingName; 403 const char* fFSVaryingName; 404 405 bool fIsDegenerate; 406 407 // @{ 408 /// Values last uploaded as uniforms 409 410 SkScalar fCachedCenter; 411 SkScalar fCachedRadius; 412 bool fCachedPosRoot; 413 414 // @} 415 416 private: 417 418 typedef GrGLGradientEffect INHERITED; 419 420 }; 421 422 ///////////////////////////////////////////////////////////////////// 423 424 class GrRadial2Gradient : public GrGradientEffect { 425 public: 426 static GrEffectRef* Create(GrContext* ctx, 427 const SkTwoPointRadialGradient& shader, 428 const SkMatrix& matrix, 429 SkShader::TileMode tm) { 430 AutoEffectUnref effect(SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm))); 431 return CreateEffectRef(effect); 432 } 433 434 virtual ~GrRadial2Gradient() { } 435 436 static const char* Name() { return "Two-Point Radial Gradient"; } 437 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { 438 return GrTBackendEffectFactory<GrRadial2Gradient>::getInstance(); 439 } 440 441 // The radial gradient parameters can collapse to a linear (instead of quadratic) equation. 442 bool isDegenerate() const { return SK_Scalar1 == fCenterX1; } 443 SkScalar center() const { return fCenterX1; } 444 SkScalar radius() const { return fRadius0; } 445 bool isPosRoot() const { return SkToBool(fPosRoot); } 446 447 typedef GrGLRadial2Gradient GLEffect; 448 449 private: 450 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 451 const GrRadial2Gradient& s = CastEffect<GrRadial2Gradient>(sBase); 452 return (INHERITED::onIsEqual(sBase) && 453 this->fCenterX1 == s.fCenterX1 && 454 this->fRadius0 == s.fRadius0 && 455 this->fPosRoot == s.fPosRoot); 456 } 457 458 GrRadial2Gradient(GrContext* ctx, 459 const SkTwoPointRadialGradient& shader, 460 const SkMatrix& matrix, 461 SkShader::TileMode tm) 462 : INHERITED(ctx, shader, matrix, tm) 463 , fCenterX1(shader.getCenterX1()) 464 , fRadius0(shader.getStartRadius()) 465 , fPosRoot(shader.getDiffRadius() < 0) { 466 // We pass the linear part of the quadratic as a varying. 467 // float b = 2.0 * (fCenterX1 * x - fRadius0 * z) 468 fBTransform = this->getCoordTransform(); 469 SkMatrix& bMatrix = *fBTransform.accessMatrix(); 470 bMatrix[SkMatrix::kMScaleX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) - 471 SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp0])); 472 bMatrix[SkMatrix::kMSkewX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) - 473 SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp1])); 474 bMatrix[SkMatrix::kMTransX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMTransX]) - 475 SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp2])); 476 this->addCoordTransform(&fBTransform); 477 } 478 479 GR_DECLARE_EFFECT_TEST; 480 481 // @{ 482 // Cache of values - these can change arbitrarily, EXCEPT 483 // we shouldn't change between degenerate and non-degenerate?! 484 485 GrCoordTransform fBTransform; 486 SkScalar fCenterX1; 487 SkScalar fRadius0; 488 SkBool8 fPosRoot; 489 490 // @} 491 492 typedef GrGradientEffect INHERITED; 493 }; 494 495 ///////////////////////////////////////////////////////////////////// 496 497 GR_DEFINE_EFFECT_TEST(GrRadial2Gradient); 498 499 GrEffectRef* GrRadial2Gradient::TestCreate(SkRandom* random, 500 GrContext* context, 501 const GrDrawTargetCaps&, 502 GrTexture**) { 503 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; 504 SkScalar radius1 = random->nextUScalar1(); 505 SkPoint center2; 506 SkScalar radius2; 507 do { 508 center2.set(random->nextUScalar1(), random->nextUScalar1()); 509 radius2 = random->nextUScalar1 (); 510 // There is a bug in two point radial gradients with identical radii 511 } while (radius1 == radius2); 512 513 SkColor colors[kMaxRandomGradientColors]; 514 SkScalar stopsArray[kMaxRandomGradientColors]; 515 SkScalar* stops = stopsArray; 516 SkShader::TileMode tm; 517 int colorCount = RandomGradientParams(random, colors, &stops, &tm); 518 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointRadial(center1, radius1, 519 center2, radius2, 520 colors, stops, colorCount, 521 tm)); 522 SkPaint paint; 523 return shader->asNewEffect(context, paint); 524 } 525 526 ///////////////////////////////////////////////////////////////////// 527 528 GrGLRadial2Gradient::GrGLRadial2Gradient(const GrBackendEffectFactory& factory, 529 const GrDrawEffect& drawEffect) 530 : INHERITED(factory) 531 , fVSVaryingName(NULL) 532 , fFSVaryingName(NULL) 533 , fCachedCenter(SK_ScalarMax) 534 , fCachedRadius(-SK_ScalarMax) 535 , fCachedPosRoot(0) { 536 537 const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>(); 538 fIsDegenerate = data.isDegenerate(); 539 } 540 541 void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder, 542 const GrDrawEffect& drawEffect, 543 EffectKey key, 544 const char* outputColor, 545 const char* inputColor, 546 const TransformedCoordsArray& coords, 547 const TextureSamplerArray& samplers) { 548 549 this->emitUniforms(builder, key); 550 fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility, 551 kFloat_GrSLType, "Radial2FSParams", 6); 552 553 SkString cName("c"); 554 SkString ac4Name("ac4"); 555 SkString rootName("root"); 556 SkString t; 557 SkString p0; 558 SkString p1; 559 SkString p2; 560 SkString p3; 561 SkString p4; 562 SkString p5; 563 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0); 564 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1); 565 builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2); 566 builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3); 567 builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4); 568 builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5); 569 570 // We interpolate the linear component in coords[1]. 571 SkASSERT(coords[0].type() == coords[1].type()); 572 const char* coords2D; 573 SkString bVar; 574 if (kVec3f_GrSLType == coords[0].type()) { 575 builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n", 576 coords[0].c_str(), coords[1].c_str(), coords[0].c_str()); 577 coords2D = "interpolants.xy"; 578 bVar = "interpolants.z"; 579 } else { 580 coords2D = coords[0].c_str(); 581 bVar.printf("%s.x", coords[1].c_str()); 582 } 583 584 // c = (x^2)+(y^2) - params[4] 585 builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", 586 cName.c_str(), coords2D, coords2D, p4.c_str()); 587 588 // If we aren't degenerate, emit some extra code, and accept a slightly 589 // more complex coord. 590 if (!fIsDegenerate) { 591 592 // ac4 = 4.0 * params[0] * c 593 builder->fsCodeAppendf("\tfloat %s = %s * 4.0 * %s;\n", 594 ac4Name.c_str(), p0.c_str(), 595 cName.c_str()); 596 597 // root = sqrt(b^2-4ac) 598 // (abs to avoid exception due to fp precision) 599 builder->fsCodeAppendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n", 600 rootName.c_str(), bVar.c_str(), bVar.c_str(), 601 ac4Name.c_str()); 602 603 // t is: (-b + params[5] * sqrt(b^2-4ac)) * params[1] 604 t.printf("(-%s + %s * %s) * %s", bVar.c_str(), p5.c_str(), 605 rootName.c_str(), p1.c_str()); 606 } else { 607 // t is: -c/b 608 t.printf("-%s / %s", cName.c_str(), bVar.c_str()); 609 } 610 611 this->emitColor(builder, t.c_str(), key, outputColor, inputColor, samplers); 612 } 613 614 void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman, 615 const GrDrawEffect& drawEffect) { 616 INHERITED::setData(uman, drawEffect); 617 const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>(); 618 SkASSERT(data.isDegenerate() == fIsDegenerate); 619 SkScalar centerX1 = data.center(); 620 SkScalar radius0 = data.radius(); 621 if (fCachedCenter != centerX1 || 622 fCachedRadius != radius0 || 623 fCachedPosRoot != data.isPosRoot()) { 624 625 SkScalar a = SkScalarMul(centerX1, centerX1) - SK_Scalar1; 626 627 // When we're in the degenerate (linear) case, the second 628 // value will be INF but the program doesn't read it. (We 629 // use the same 6 uniforms even though we don't need them 630 // all in the linear case just to keep the code complexity 631 // down). 632 float values[6] = { 633 SkScalarToFloat(a), 634 1 / (2.f * SkScalarToFloat(a)), 635 SkScalarToFloat(centerX1), 636 SkScalarToFloat(radius0), 637 SkScalarToFloat(SkScalarMul(radius0, radius0)), 638 data.isPosRoot() ? 1.f : -1.f 639 }; 640 641 uman.set1fv(fParamUni, 6, values); 642 fCachedCenter = centerX1; 643 fCachedRadius = radius0; 644 fCachedPosRoot = data.isPosRoot(); 645 } 646 } 647 648 GrGLEffect::EffectKey GrGLRadial2Gradient::GenKey(const GrDrawEffect& drawEffect, 649 const GrGLCaps&) { 650 enum { 651 kIsDegenerate = 1 << kBaseKeyBitCnt, 652 }; 653 654 EffectKey key = GenBaseGradientKey(drawEffect); 655 if (drawEffect.castEffect<GrRadial2Gradient>().isDegenerate()) { 656 key |= kIsDegenerate; 657 } 658 return key; 659 } 660 661 ///////////////////////////////////////////////////////////////////// 662 663 GrEffectRef* SkTwoPointRadialGradient::asNewEffect(GrContext* context, const SkPaint&) const { 664 SkASSERT(NULL != context); 665 // invert the localM, translate to center1 (fPtsToUni), rotate so center2 is on x axis. 666 SkMatrix matrix; 667 if (!this->getLocalMatrix().invert(&matrix)) { 668 return NULL; 669 } 670 matrix.postConcat(fPtsToUnit); 671 672 SkScalar diffLen = fDiff.length(); 673 if (0 != diffLen) { 674 SkScalar invDiffLen = SkScalarInvert(diffLen); 675 SkMatrix rot; 676 rot.setSinCos(-SkScalarMul(invDiffLen, fDiff.fY), 677 SkScalarMul(invDiffLen, fDiff.fX)); 678 matrix.postConcat(rot); 679 } 680 681 return GrRadial2Gradient::Create(context, *this, matrix, fTileMode); 682 } 683 684 #else 685 686 GrEffectRef* SkTwoPointRadialGradient::asNewEffect(GrContext*, const SkPaint&) const { 687 SkDEBUGFAIL("Should not call in GPU-less build"); 688 return NULL; 689 } 690 691 #endif 692