1 /* 2 * Copyright 2012 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 "SkLightingImageFilter.h" 9 #include "SkBitmap.h" 10 #include "SkColorPriv.h" 11 #include "SkReadBuffer.h" 12 #include "SkWriteBuffer.h" 13 #include "SkReadBuffer.h" 14 #include "SkWriteBuffer.h" 15 #include "SkTypes.h" 16 17 #if SK_SUPPORT_GPU 18 #include "effects/GrSingleTextureEffect.h" 19 #include "gl/GrGLProcessor.h" 20 #include "gl/builders/GrGLProgramBuilder.h" 21 #include "GrProcessor.h" 22 #include "GrTBackendProcessorFactory.h" 23 24 class GrGLDiffuseLightingEffect; 25 class GrGLSpecularLightingEffect; 26 27 // For brevity 28 typedef GrGLProgramDataManager::UniformHandle UniformHandle; 29 #endif 30 31 namespace { 32 33 const SkScalar gOneThird = SkScalarInvert(SkIntToScalar(3)); 34 const SkScalar gTwoThirds = SkScalarDiv(SkIntToScalar(2), SkIntToScalar(3)); 35 const SkScalar gOneHalf = 0.5f; 36 const SkScalar gOneQuarter = 0.25f; 37 38 #if SK_SUPPORT_GPU 39 void setUniformPoint3(const GrGLProgramDataManager& pdman, UniformHandle uni, 40 const SkPoint3& point) { 41 GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(GrGLfloat)); 42 pdman.set3fv(uni, 1, &point.fX); 43 } 44 45 void setUniformNormal3(const GrGLProgramDataManager& pdman, UniformHandle uni, 46 const SkPoint3& point) { 47 setUniformPoint3(pdman, uni, SkPoint3(point.fX, point.fY, point.fZ)); 48 } 49 #endif 50 51 // Shift matrix components to the left, as we advance pixels to the right. 52 inline void shiftMatrixLeft(int m[9]) { 53 m[0] = m[1]; 54 m[3] = m[4]; 55 m[6] = m[7]; 56 m[1] = m[2]; 57 m[4] = m[5]; 58 m[7] = m[8]; 59 } 60 61 class DiffuseLightingType { 62 public: 63 DiffuseLightingType(SkScalar kd) 64 : fKD(kd) {} 65 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, 66 const SkPoint3& lightColor) const { 67 SkScalar colorScale = SkScalarMul(fKD, normal.dot(surfaceTolight)); 68 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); 69 SkPoint3 color(lightColor * colorScale); 70 return SkPackARGB32(255, 71 SkClampMax(SkScalarRoundToInt(color.fX), 255), 72 SkClampMax(SkScalarRoundToInt(color.fY), 255), 73 SkClampMax(SkScalarRoundToInt(color.fZ), 255)); 74 } 75 private: 76 SkScalar fKD; 77 }; 78 79 class SpecularLightingType { 80 public: 81 SpecularLightingType(SkScalar ks, SkScalar shininess) 82 : fKS(ks), fShininess(shininess) {} 83 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, 84 const SkPoint3& lightColor) const { 85 SkPoint3 halfDir(surfaceTolight); 86 halfDir.fZ += SK_Scalar1; // eye position is always (0, 0, 1) 87 halfDir.normalize(); 88 SkScalar colorScale = SkScalarMul(fKS, 89 SkScalarPow(normal.dot(halfDir), fShininess)); 90 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); 91 SkPoint3 color(lightColor * colorScale); 92 return SkPackARGB32(SkClampMax(SkScalarRoundToInt(color.maxComponent()), 255), 93 SkClampMax(SkScalarRoundToInt(color.fX), 255), 94 SkClampMax(SkScalarRoundToInt(color.fY), 255), 95 SkClampMax(SkScalarRoundToInt(color.fZ), 255)); 96 } 97 private: 98 SkScalar fKS; 99 SkScalar fShininess; 100 }; 101 102 inline SkScalar sobel(int a, int b, int c, int d, int e, int f, SkScalar scale) { 103 return SkScalarMul(SkIntToScalar(-a + b - 2 * c + 2 * d -e + f), scale); 104 } 105 106 inline SkPoint3 pointToNormal(SkScalar x, SkScalar y, SkScalar surfaceScale) { 107 SkPoint3 vector(SkScalarMul(-x, surfaceScale), 108 SkScalarMul(-y, surfaceScale), 109 SK_Scalar1); 110 vector.normalize(); 111 return vector; 112 } 113 114 inline SkPoint3 topLeftNormal(int m[9], SkScalar surfaceScale) { 115 return pointToNormal(sobel(0, 0, m[4], m[5], m[7], m[8], gTwoThirds), 116 sobel(0, 0, m[4], m[7], m[5], m[8], gTwoThirds), 117 surfaceScale); 118 } 119 120 inline SkPoint3 topNormal(int m[9], SkScalar surfaceScale) { 121 return pointToNormal(sobel( 0, 0, m[3], m[5], m[6], m[8], gOneThird), 122 sobel(m[3], m[6], m[4], m[7], m[5], m[8], gOneHalf), 123 surfaceScale); 124 } 125 126 inline SkPoint3 topRightNormal(int m[9], SkScalar surfaceScale) { 127 return pointToNormal(sobel( 0, 0, m[3], m[4], m[6], m[7], gTwoThirds), 128 sobel(m[3], m[6], m[4], m[7], 0, 0, gTwoThirds), 129 surfaceScale); 130 } 131 132 inline SkPoint3 leftNormal(int m[9], SkScalar surfaceScale) { 133 return pointToNormal(sobel(m[1], m[2], m[4], m[5], m[7], m[8], gOneHalf), 134 sobel( 0, 0, m[1], m[7], m[2], m[8], gOneThird), 135 surfaceScale); 136 } 137 138 139 inline SkPoint3 interiorNormal(int m[9], SkScalar surfaceScale) { 140 return pointToNormal(sobel(m[0], m[2], m[3], m[5], m[6], m[8], gOneQuarter), 141 sobel(m[0], m[6], m[1], m[7], m[2], m[8], gOneQuarter), 142 surfaceScale); 143 } 144 145 inline SkPoint3 rightNormal(int m[9], SkScalar surfaceScale) { 146 return pointToNormal(sobel(m[0], m[1], m[3], m[4], m[6], m[7], gOneHalf), 147 sobel(m[0], m[6], m[1], m[7], 0, 0, gOneThird), 148 surfaceScale); 149 } 150 151 inline SkPoint3 bottomLeftNormal(int m[9], SkScalar surfaceScale) { 152 return pointToNormal(sobel(m[1], m[2], m[4], m[5], 0, 0, gTwoThirds), 153 sobel( 0, 0, m[1], m[4], m[2], m[5], gTwoThirds), 154 surfaceScale); 155 } 156 157 inline SkPoint3 bottomNormal(int m[9], SkScalar surfaceScale) { 158 return pointToNormal(sobel(m[0], m[2], m[3], m[5], 0, 0, gOneThird), 159 sobel(m[0], m[3], m[1], m[4], m[2], m[5], gOneHalf), 160 surfaceScale); 161 } 162 163 inline SkPoint3 bottomRightNormal(int m[9], SkScalar surfaceScale) { 164 return pointToNormal(sobel(m[0], m[1], m[3], m[4], 0, 0, gTwoThirds), 165 sobel(m[0], m[3], m[1], m[4], 0, 0, gTwoThirds), 166 surfaceScale); 167 } 168 169 template <class LightingType, class LightType> void lightBitmap( 170 const LightingType& lightingType, const SkLight* light, const SkBitmap& src, SkBitmap* dst, 171 SkScalar surfaceScale, const SkIRect& bounds) { 172 SkASSERT(dst->width() == bounds.width() && dst->height() == bounds.height()); 173 const LightType* l = static_cast<const LightType*>(light); 174 int left = bounds.left(), right = bounds.right(); 175 int bottom = bounds.bottom(); 176 int y = bounds.top(); 177 SkPMColor* dptr = dst->getAddr32(0, 0); 178 { 179 int x = left; 180 const SkPMColor* row1 = src.getAddr32(x, y); 181 const SkPMColor* row2 = src.getAddr32(x, y + 1); 182 int m[9]; 183 m[4] = SkGetPackedA32(*row1++); 184 m[5] = SkGetPackedA32(*row1++); 185 m[7] = SkGetPackedA32(*row2++); 186 m[8] = SkGetPackedA32(*row2++); 187 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 188 *dptr++ = lightingType.light(topLeftNormal(m, surfaceScale), surfaceToLight, 189 l->lightColor(surfaceToLight)); 190 for (++x; x < right - 1; ++x) 191 { 192 shiftMatrixLeft(m); 193 m[5] = SkGetPackedA32(*row1++); 194 m[8] = SkGetPackedA32(*row2++); 195 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 196 *dptr++ = lightingType.light(topNormal(m, surfaceScale), surfaceToLight, 197 l->lightColor(surfaceToLight)); 198 } 199 shiftMatrixLeft(m); 200 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 201 *dptr++ = lightingType.light(topRightNormal(m, surfaceScale), surfaceToLight, 202 l->lightColor(surfaceToLight)); 203 } 204 205 for (++y; y < bottom - 1; ++y) { 206 int x = left; 207 const SkPMColor* row0 = src.getAddr32(x, y - 1); 208 const SkPMColor* row1 = src.getAddr32(x, y); 209 const SkPMColor* row2 = src.getAddr32(x, y + 1); 210 int m[9]; 211 m[1] = SkGetPackedA32(*row0++); 212 m[2] = SkGetPackedA32(*row0++); 213 m[4] = SkGetPackedA32(*row1++); 214 m[5] = SkGetPackedA32(*row1++); 215 m[7] = SkGetPackedA32(*row2++); 216 m[8] = SkGetPackedA32(*row2++); 217 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 218 *dptr++ = lightingType.light(leftNormal(m, surfaceScale), surfaceToLight, 219 l->lightColor(surfaceToLight)); 220 for (++x; x < right - 1; ++x) { 221 shiftMatrixLeft(m); 222 m[2] = SkGetPackedA32(*row0++); 223 m[5] = SkGetPackedA32(*row1++); 224 m[8] = SkGetPackedA32(*row2++); 225 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 226 *dptr++ = lightingType.light(interiorNormal(m, surfaceScale), surfaceToLight, 227 l->lightColor(surfaceToLight)); 228 } 229 shiftMatrixLeft(m); 230 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 231 *dptr++ = lightingType.light(rightNormal(m, surfaceScale), surfaceToLight, 232 l->lightColor(surfaceToLight)); 233 } 234 235 { 236 int x = left; 237 const SkPMColor* row0 = src.getAddr32(x, bottom - 2); 238 const SkPMColor* row1 = src.getAddr32(x, bottom - 1); 239 int m[9]; 240 m[1] = SkGetPackedA32(*row0++); 241 m[2] = SkGetPackedA32(*row0++); 242 m[4] = SkGetPackedA32(*row1++); 243 m[5] = SkGetPackedA32(*row1++); 244 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 245 *dptr++ = lightingType.light(bottomLeftNormal(m, surfaceScale), surfaceToLight, 246 l->lightColor(surfaceToLight)); 247 for (++x; x < right - 1; ++x) 248 { 249 shiftMatrixLeft(m); 250 m[2] = SkGetPackedA32(*row0++); 251 m[5] = SkGetPackedA32(*row1++); 252 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 253 *dptr++ = lightingType.light(bottomNormal(m, surfaceScale), surfaceToLight, 254 l->lightColor(surfaceToLight)); 255 } 256 shiftMatrixLeft(m); 257 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); 258 *dptr++ = lightingType.light(bottomRightNormal(m, surfaceScale), surfaceToLight, 259 l->lightColor(surfaceToLight)); 260 } 261 } 262 263 SkPoint3 readPoint3(SkReadBuffer& buffer) { 264 SkPoint3 point; 265 point.fX = buffer.readScalar(); 266 point.fY = buffer.readScalar(); 267 point.fZ = buffer.readScalar(); 268 buffer.validate(SkScalarIsFinite(point.fX) && 269 SkScalarIsFinite(point.fY) && 270 SkScalarIsFinite(point.fZ)); 271 return point; 272 }; 273 274 void writePoint3(const SkPoint3& point, SkWriteBuffer& buffer) { 275 buffer.writeScalar(point.fX); 276 buffer.writeScalar(point.fY); 277 buffer.writeScalar(point.fZ); 278 }; 279 280 class SkDiffuseLightingImageFilter : public SkLightingImageFilter { 281 public: 282 static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter*, 283 const CropRect*, uint32_t uniqueID = 0); 284 285 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter) 286 SkScalar kd() const { return fKD; } 287 288 protected: 289 SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, 290 SkScalar kd, SkImageFilter* input, const CropRect* cropRect, 291 uint32_t uniqueID); 292 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 293 explicit SkDiffuseLightingImageFilter(SkReadBuffer& buffer); 294 #endif 295 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; 296 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, 297 SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE; 298 #if SK_SUPPORT_GPU 299 virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&, 300 const SkIRect& bounds) const SK_OVERRIDE; 301 #endif 302 303 private: 304 friend class SkLightingImageFilter; 305 typedef SkLightingImageFilter INHERITED; 306 SkScalar fKD; 307 }; 308 309 class SkSpecularLightingImageFilter : public SkLightingImageFilter { 310 public: 311 static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, 312 SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*, 313 uint32_t uniqueID = 0); 314 315 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter) 316 317 SkScalar ks() const { return fKS; } 318 SkScalar shininess() const { return fShininess; } 319 320 protected: 321 SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, 322 SkScalar shininess, SkImageFilter* input, const CropRect*, 323 uint32_t uniqueID); 324 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 325 explicit SkSpecularLightingImageFilter(SkReadBuffer& buffer); 326 #endif 327 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; 328 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, 329 SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE; 330 #if SK_SUPPORT_GPU 331 virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&, 332 const SkIRect& bounds) const SK_OVERRIDE; 333 #endif 334 335 private: 336 SkScalar fKS; 337 SkScalar fShininess; 338 friend class SkLightingImageFilter; 339 typedef SkLightingImageFilter INHERITED; 340 }; 341 342 #if SK_SUPPORT_GPU 343 344 class GrLightingEffect : public GrSingleTextureEffect { 345 public: 346 GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceScale, const SkMatrix& matrix); 347 virtual ~GrLightingEffect(); 348 349 const SkLight* light() const { return fLight; } 350 SkScalar surfaceScale() const { return fSurfaceScale; } 351 const SkMatrix& filterMatrix() const { return fFilterMatrix; } 352 353 virtual void getConstantColorComponents(GrColor* color, 354 uint32_t* validFlags) const SK_OVERRIDE { 355 // lighting shaders are complicated. We just throw up our hands. 356 *validFlags = 0; 357 } 358 359 protected: 360 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; 361 362 private: 363 typedef GrSingleTextureEffect INHERITED; 364 const SkLight* fLight; 365 SkScalar fSurfaceScale; 366 SkMatrix fFilterMatrix; 367 }; 368 369 class GrDiffuseLightingEffect : public GrLightingEffect { 370 public: 371 static GrFragmentProcessor* Create(GrTexture* texture, 372 const SkLight* light, 373 SkScalar surfaceScale, 374 const SkMatrix& matrix, 375 SkScalar kd) { 376 return SkNEW_ARGS(GrDiffuseLightingEffect, (texture, 377 light, 378 surfaceScale, 379 matrix, 380 kd)); 381 } 382 383 static const char* Name() { return "DiffuseLighting"; } 384 385 typedef GrGLDiffuseLightingEffect GLProcessor; 386 387 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE; 388 SkScalar kd() const { return fKD; } 389 390 private: 391 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; 392 393 GrDiffuseLightingEffect(GrTexture* texture, 394 const SkLight* light, 395 SkScalar surfaceScale, 396 const SkMatrix& matrix, 397 SkScalar kd); 398 399 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; 400 typedef GrLightingEffect INHERITED; 401 SkScalar fKD; 402 }; 403 404 class GrSpecularLightingEffect : public GrLightingEffect { 405 public: 406 static GrFragmentProcessor* Create(GrTexture* texture, 407 const SkLight* light, 408 SkScalar surfaceScale, 409 const SkMatrix& matrix, 410 SkScalar ks, 411 SkScalar shininess) { 412 return SkNEW_ARGS(GrSpecularLightingEffect, (texture, 413 light, 414 surfaceScale, 415 matrix, 416 ks, 417 shininess)); 418 } 419 static const char* Name() { return "SpecularLighting"; } 420 421 typedef GrGLSpecularLightingEffect GLProcessor; 422 423 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE; 424 SkScalar ks() const { return fKS; } 425 SkScalar shininess() const { return fShininess; } 426 427 private: 428 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; 429 430 GrSpecularLightingEffect(GrTexture* texture, 431 const SkLight* light, 432 SkScalar surfaceScale, 433 const SkMatrix& matrix, 434 SkScalar ks, 435 SkScalar shininess); 436 437 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; 438 typedef GrLightingEffect INHERITED; 439 SkScalar fKS; 440 SkScalar fShininess; 441 }; 442 443 /////////////////////////////////////////////////////////////////////////////// 444 445 class GrGLLight { 446 public: 447 virtual ~GrGLLight() {} 448 449 /** 450 * This is called by GrGLLightingEffect::emitCode() before either of the two virtual functions 451 * below. It adds a vec3f uniform visible in the FS that represents the constant light color. 452 */ 453 void emitLightColorUniform(GrGLProgramBuilder*); 454 455 /** 456 * These two functions are called from GrGLLightingEffect's emitCode() function. 457 * emitSurfaceToLight places an expression in param out that is the vector from the surface to 458 * the light. The expression will be used in the FS. emitLightColor writes an expression into 459 * the FS that is the color of the light. Either function may add functions and/or uniforms to 460 * the FS. The default of emitLightColor appends the name of the constant light color uniform 461 * and so this function only needs to be overridden if the light color varies spatially. 462 */ 463 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) = 0; 464 virtual void emitLightColor(GrGLProgramBuilder*, const char *surfaceToLight); 465 466 // This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLight must call 467 // INHERITED::setData(). 468 virtual void setData(const GrGLProgramDataManager&, 469 const SkLight* light) const; 470 471 protected: 472 /** 473 * Gets the constant light color uniform. Subclasses can use this in their emitLightColor 474 * function. 475 */ 476 UniformHandle lightColorUni() const { return fColorUni; } 477 478 private: 479 UniformHandle fColorUni; 480 481 typedef SkRefCnt INHERITED; 482 }; 483 484 /////////////////////////////////////////////////////////////////////////////// 485 486 class GrGLDistantLight : public GrGLLight { 487 public: 488 virtual ~GrGLDistantLight() {} 489 virtual void setData(const GrGLProgramDataManager&, 490 const SkLight* light) const SK_OVERRIDE; 491 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERRIDE; 492 493 private: 494 typedef GrGLLight INHERITED; 495 UniformHandle fDirectionUni; 496 }; 497 498 /////////////////////////////////////////////////////////////////////////////// 499 500 class GrGLPointLight : public GrGLLight { 501 public: 502 virtual ~GrGLPointLight() {} 503 virtual void setData(const GrGLProgramDataManager&, 504 const SkLight* light) const SK_OVERRIDE; 505 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERRIDE; 506 507 private: 508 typedef GrGLLight INHERITED; 509 UniformHandle fLocationUni; 510 }; 511 512 /////////////////////////////////////////////////////////////////////////////// 513 514 class GrGLSpotLight : public GrGLLight { 515 public: 516 virtual ~GrGLSpotLight() {} 517 virtual void setData(const GrGLProgramDataManager&, 518 const SkLight* light) const SK_OVERRIDE; 519 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERRIDE; 520 virtual void emitLightColor(GrGLProgramBuilder*, const char *surfaceToLight) SK_OVERRIDE; 521 522 private: 523 typedef GrGLLight INHERITED; 524 525 SkString fLightColorFunc; 526 UniformHandle fLocationUni; 527 UniformHandle fExponentUni; 528 UniformHandle fCosOuterConeAngleUni; 529 UniformHandle fCosInnerConeAngleUni; 530 UniformHandle fConeScaleUni; 531 UniformHandle fSUni; 532 }; 533 #else 534 535 class GrGLLight; 536 537 #endif 538 539 }; 540 541 /////////////////////////////////////////////////////////////////////////////// 542 543 class SkLight : public SkRefCnt { 544 public: 545 SK_DECLARE_INST_COUNT(SkLight) 546 547 enum LightType { 548 kDistant_LightType, 549 kPoint_LightType, 550 kSpot_LightType, 551 }; 552 virtual LightType type() const = 0; 553 const SkPoint3& color() const { return fColor; } 554 virtual GrGLLight* createGLLight() const = 0; 555 virtual bool isEqual(const SkLight& other) const { 556 return fColor == other.fColor; 557 } 558 // Called to know whether the generated GrGLLight will require access to the fragment position. 559 virtual bool requiresFragmentPosition() const = 0; 560 virtual SkLight* transform(const SkMatrix& matrix) const = 0; 561 562 // Defined below SkLight's subclasses. 563 void flattenLight(SkWriteBuffer& buffer) const; 564 static SkLight* UnflattenLight(SkReadBuffer& buffer); 565 566 protected: 567 SkLight(SkColor color) 568 : fColor(SkIntToScalar(SkColorGetR(color)), 569 SkIntToScalar(SkColorGetG(color)), 570 SkIntToScalar(SkColorGetB(color))) {} 571 SkLight(const SkPoint3& color) 572 : fColor(color) {} 573 SkLight(SkReadBuffer& buffer) { 574 fColor = readPoint3(buffer); 575 } 576 577 virtual void onFlattenLight(SkWriteBuffer& buffer) const = 0; 578 579 580 private: 581 typedef SkRefCnt INHERITED; 582 SkPoint3 fColor; 583 }; 584 585 /////////////////////////////////////////////////////////////////////////////// 586 587 class SkDistantLight : public SkLight { 588 public: 589 SkDistantLight(const SkPoint3& direction, SkColor color) 590 : INHERITED(color), fDirection(direction) { 591 } 592 593 SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const { 594 return fDirection; 595 }; 596 SkPoint3 lightColor(const SkPoint3&) const { return color(); } 597 virtual LightType type() const { return kDistant_LightType; } 598 const SkPoint3& direction() const { return fDirection; } 599 virtual GrGLLight* createGLLight() const SK_OVERRIDE { 600 #if SK_SUPPORT_GPU 601 return SkNEW(GrGLDistantLight); 602 #else 603 SkDEBUGFAIL("Should not call in GPU-less build"); 604 return NULL; 605 #endif 606 } 607 virtual bool requiresFragmentPosition() const SK_OVERRIDE { return false; } 608 609 virtual bool isEqual(const SkLight& other) const SK_OVERRIDE { 610 if (other.type() != kDistant_LightType) { 611 return false; 612 } 613 614 const SkDistantLight& o = static_cast<const SkDistantLight&>(other); 615 return INHERITED::isEqual(other) && 616 fDirection == o.fDirection; 617 } 618 619 SkDistantLight(SkReadBuffer& buffer) : INHERITED(buffer) { 620 fDirection = readPoint3(buffer); 621 } 622 623 protected: 624 SkDistantLight(const SkPoint3& direction, const SkPoint3& color) 625 : INHERITED(color), fDirection(direction) { 626 } 627 virtual SkLight* transform(const SkMatrix& matrix) const { 628 return new SkDistantLight(direction(), color()); 629 } 630 virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE { 631 writePoint3(fDirection, buffer); 632 } 633 634 private: 635 typedef SkLight INHERITED; 636 SkPoint3 fDirection; 637 }; 638 639 /////////////////////////////////////////////////////////////////////////////// 640 641 class SkPointLight : public SkLight { 642 public: 643 SkPointLight(const SkPoint3& location, SkColor color) 644 : INHERITED(color), fLocation(location) {} 645 646 SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const { 647 SkPoint3 direction(fLocation.fX - SkIntToScalar(x), 648 fLocation.fY - SkIntToScalar(y), 649 fLocation.fZ - SkScalarMul(SkIntToScalar(z), surfaceScale)); 650 direction.normalize(); 651 return direction; 652 }; 653 SkPoint3 lightColor(const SkPoint3&) const { return color(); } 654 virtual LightType type() const { return kPoint_LightType; } 655 const SkPoint3& location() const { return fLocation; } 656 virtual GrGLLight* createGLLight() const SK_OVERRIDE { 657 #if SK_SUPPORT_GPU 658 return SkNEW(GrGLPointLight); 659 #else 660 SkDEBUGFAIL("Should not call in GPU-less build"); 661 return NULL; 662 #endif 663 } 664 virtual bool requiresFragmentPosition() const SK_OVERRIDE { return true; } 665 virtual bool isEqual(const SkLight& other) const SK_OVERRIDE { 666 if (other.type() != kPoint_LightType) { 667 return false; 668 } 669 const SkPointLight& o = static_cast<const SkPointLight&>(other); 670 return INHERITED::isEqual(other) && 671 fLocation == o.fLocation; 672 } 673 virtual SkLight* transform(const SkMatrix& matrix) const { 674 SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY); 675 matrix.mapPoints(&location2, 1); 676 // Use X scale and Y scale on Z and average the result 677 SkPoint locationZ = SkPoint::Make(fLocation.fZ, fLocation.fZ); 678 matrix.mapVectors(&locationZ, 1); 679 SkPoint3 location(location2.fX, location2.fY, SkScalarAve(locationZ.fX, locationZ.fY)); 680 return new SkPointLight(location, color()); 681 } 682 683 SkPointLight(SkReadBuffer& buffer) : INHERITED(buffer) { 684 fLocation = readPoint3(buffer); 685 } 686 687 protected: 688 SkPointLight(const SkPoint3& location, const SkPoint3& color) 689 : INHERITED(color), fLocation(location) {} 690 virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE { 691 writePoint3(fLocation, buffer); 692 } 693 694 private: 695 typedef SkLight INHERITED; 696 SkPoint3 fLocation; 697 }; 698 699 /////////////////////////////////////////////////////////////////////////////// 700 701 class SkSpotLight : public SkLight { 702 public: 703 SkSpotLight(const SkPoint3& location, const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle, SkColor color) 704 : INHERITED(color), 705 fLocation(location), 706 fTarget(target), 707 fSpecularExponent(SkScalarPin(specularExponent, kSpecularExponentMin, kSpecularExponentMax)) 708 { 709 fS = target - location; 710 fS.normalize(); 711 fCosOuterConeAngle = SkScalarCos(SkDegreesToRadians(cutoffAngle)); 712 const SkScalar antiAliasThreshold = 0.016f; 713 fCosInnerConeAngle = fCosOuterConeAngle + antiAliasThreshold; 714 fConeScale = SkScalarInvert(antiAliasThreshold); 715 } 716 717 virtual SkLight* transform(const SkMatrix& matrix) const { 718 SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY); 719 matrix.mapPoints(&location2, 1); 720 // Use X scale and Y scale on Z and average the result 721 SkPoint locationZ = SkPoint::Make(fLocation.fZ, fLocation.fZ); 722 matrix.mapVectors(&locationZ, 1); 723 SkPoint3 location(location2.fX, location2.fY, SkScalarAve(locationZ.fX, locationZ.fY)); 724 SkPoint target2 = SkPoint::Make(fTarget.fX, fTarget.fY); 725 matrix.mapPoints(&target2, 1); 726 SkPoint targetZ = SkPoint::Make(fTarget.fZ, fTarget.fZ); 727 matrix.mapVectors(&targetZ, 1); 728 SkPoint3 target(target2.fX, target2.fY, SkScalarAve(targetZ.fX, targetZ.fY)); 729 SkPoint3 s = target - location; 730 s.normalize(); 731 return new SkSpotLight(location, target, fSpecularExponent, fCosOuterConeAngle, fCosInnerConeAngle, fConeScale, s, color()); 732 } 733 734 SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const { 735 SkPoint3 direction(fLocation.fX - SkIntToScalar(x), 736 fLocation.fY - SkIntToScalar(y), 737 fLocation.fZ - SkScalarMul(SkIntToScalar(z), surfaceScale)); 738 direction.normalize(); 739 return direction; 740 }; 741 SkPoint3 lightColor(const SkPoint3& surfaceToLight) const { 742 SkScalar cosAngle = -surfaceToLight.dot(fS); 743 if (cosAngle < fCosOuterConeAngle) { 744 return SkPoint3(0, 0, 0); 745 } 746 SkScalar scale = SkScalarPow(cosAngle, fSpecularExponent); 747 if (cosAngle < fCosInnerConeAngle) { 748 scale = SkScalarMul(scale, cosAngle - fCosOuterConeAngle); 749 return color() * SkScalarMul(scale, fConeScale); 750 } 751 return color() * scale; 752 } 753 virtual GrGLLight* createGLLight() const SK_OVERRIDE { 754 #if SK_SUPPORT_GPU 755 return SkNEW(GrGLSpotLight); 756 #else 757 SkDEBUGFAIL("Should not call in GPU-less build"); 758 return NULL; 759 #endif 760 } 761 virtual bool requiresFragmentPosition() const SK_OVERRIDE { return true; } 762 virtual LightType type() const { return kSpot_LightType; } 763 const SkPoint3& location() const { return fLocation; } 764 const SkPoint3& target() const { return fTarget; } 765 SkScalar specularExponent() const { return fSpecularExponent; } 766 SkScalar cosInnerConeAngle() const { return fCosInnerConeAngle; } 767 SkScalar cosOuterConeAngle() const { return fCosOuterConeAngle; } 768 SkScalar coneScale() const { return fConeScale; } 769 const SkPoint3& s() const { return fS; } 770 771 SkSpotLight(SkReadBuffer& buffer) : INHERITED(buffer) { 772 fLocation = readPoint3(buffer); 773 fTarget = readPoint3(buffer); 774 fSpecularExponent = buffer.readScalar(); 775 fCosOuterConeAngle = buffer.readScalar(); 776 fCosInnerConeAngle = buffer.readScalar(); 777 fConeScale = buffer.readScalar(); 778 fS = readPoint3(buffer); 779 buffer.validate(SkScalarIsFinite(fSpecularExponent) && 780 SkScalarIsFinite(fCosOuterConeAngle) && 781 SkScalarIsFinite(fCosInnerConeAngle) && 782 SkScalarIsFinite(fConeScale)); 783 } 784 protected: 785 SkSpotLight(const SkPoint3& location, const SkPoint3& target, SkScalar specularExponent, SkScalar cosOuterConeAngle, SkScalar cosInnerConeAngle, SkScalar coneScale, const SkPoint3& s, const SkPoint3& color) 786 : INHERITED(color), 787 fLocation(location), 788 fTarget(target), 789 fSpecularExponent(specularExponent), 790 fCosOuterConeAngle(cosOuterConeAngle), 791 fCosInnerConeAngle(cosInnerConeAngle), 792 fConeScale(coneScale), 793 fS(s) 794 { 795 } 796 virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE { 797 writePoint3(fLocation, buffer); 798 writePoint3(fTarget, buffer); 799 buffer.writeScalar(fSpecularExponent); 800 buffer.writeScalar(fCosOuterConeAngle); 801 buffer.writeScalar(fCosInnerConeAngle); 802 buffer.writeScalar(fConeScale); 803 writePoint3(fS, buffer); 804 } 805 806 virtual bool isEqual(const SkLight& other) const SK_OVERRIDE { 807 if (other.type() != kSpot_LightType) { 808 return false; 809 } 810 811 const SkSpotLight& o = static_cast<const SkSpotLight&>(other); 812 return INHERITED::isEqual(other) && 813 fLocation == o.fLocation && 814 fTarget == o.fTarget && 815 fSpecularExponent == o.fSpecularExponent && 816 fCosOuterConeAngle == o.fCosOuterConeAngle; 817 } 818 819 private: 820 static const SkScalar kSpecularExponentMin; 821 static const SkScalar kSpecularExponentMax; 822 823 typedef SkLight INHERITED; 824 SkPoint3 fLocation; 825 SkPoint3 fTarget; 826 SkScalar fSpecularExponent; 827 SkScalar fCosOuterConeAngle; 828 SkScalar fCosInnerConeAngle; 829 SkScalar fConeScale; 830 SkPoint3 fS; 831 }; 832 833 // According to the spec, the specular term should be in the range [1, 128] : 834 // http://www.w3.org/TR/SVG/filters.html#feSpecularLightingSpecularExponentAttribute 835 const SkScalar SkSpotLight::kSpecularExponentMin = 1.0f; 836 const SkScalar SkSpotLight::kSpecularExponentMax = 128.0f; 837 838 /////////////////////////////////////////////////////////////////////////////// 839 840 void SkLight::flattenLight(SkWriteBuffer& buffer) const { 841 // Write type first, then baseclass, then subclass. 842 buffer.writeInt(this->type()); 843 writePoint3(fColor, buffer); 844 this->onFlattenLight(buffer); 845 } 846 847 /*static*/ SkLight* SkLight::UnflattenLight(SkReadBuffer& buffer) { 848 // Read type first. 849 const SkLight::LightType type = (SkLight::LightType)buffer.readInt(); 850 switch (type) { 851 // Each of these constructors must first call SkLight's, so we'll read the baseclass 852 // then subclass, same order as flattenLight. 853 case SkLight::kDistant_LightType: return SkNEW_ARGS(SkDistantLight, (buffer)); 854 case SkLight::kPoint_LightType: return SkNEW_ARGS(SkPointLight, (buffer)); 855 case SkLight::kSpot_LightType: return SkNEW_ARGS(SkSpotLight, (buffer)); 856 default: 857 SkDEBUGFAIL("Unknown LightType."); 858 buffer.validate(false); 859 return NULL; 860 } 861 } 862 /////////////////////////////////////////////////////////////////////////////// 863 864 SkLightingImageFilter::SkLightingImageFilter(SkLight* light, SkScalar surfaceScale, 865 SkImageFilter* input, const CropRect* cropRect, 866 uint32_t uniqueID) 867 : INHERITED(1, &input, cropRect, uniqueID) 868 , fLight(SkRef(light)) 869 , fSurfaceScale(surfaceScale / 255) 870 {} 871 872 SkImageFilter* SkLightingImageFilter::CreateDistantLitDiffuse(const SkPoint3& direction, 873 SkColor lightColor, 874 SkScalar surfaceScale, 875 SkScalar kd, 876 SkImageFilter* input, 877 const CropRect* cropRect) { 878 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor))); 879 return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect); 880 } 881 882 SkImageFilter* SkLightingImageFilter::CreatePointLitDiffuse(const SkPoint3& location, 883 SkColor lightColor, 884 SkScalar surfaceScale, 885 SkScalar kd, 886 SkImageFilter* input, 887 const CropRect* cropRect) { 888 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor))); 889 return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect); 890 } 891 892 SkImageFilter* SkLightingImageFilter::CreateSpotLitDiffuse(const SkPoint3& location, 893 const SkPoint3& target, 894 SkScalar specularExponent, 895 SkScalar cutoffAngle, 896 SkColor lightColor, 897 SkScalar surfaceScale, 898 SkScalar kd, 899 SkImageFilter* input, 900 const CropRect* cropRect) { 901 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent, 902 cutoffAngle, lightColor))); 903 return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect); 904 } 905 906 SkImageFilter* SkLightingImageFilter::CreateDistantLitSpecular(const SkPoint3& direction, 907 SkColor lightColor, 908 SkScalar surfaceScale, 909 SkScalar ks, 910 SkScalar shine, 911 SkImageFilter* input, 912 const CropRect* cropRect) { 913 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor))); 914 return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect); 915 } 916 917 SkImageFilter* SkLightingImageFilter::CreatePointLitSpecular(const SkPoint3& location, 918 SkColor lightColor, 919 SkScalar surfaceScale, 920 SkScalar ks, 921 SkScalar shine, 922 SkImageFilter* input, 923 const CropRect* cropRect) { 924 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor))); 925 return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect); 926 } 927 928 SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(const SkPoint3& location, 929 const SkPoint3& target, 930 SkScalar specularExponent, 931 SkScalar cutoffAngle, 932 SkColor lightColor, 933 SkScalar surfaceScale, 934 SkScalar ks, 935 SkScalar shine, 936 SkImageFilter* input, 937 const CropRect* cropRect) { 938 SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent, 939 cutoffAngle, lightColor))); 940 return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect); 941 } 942 943 SkLightingImageFilter::~SkLightingImageFilter() {} 944 945 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 946 SkLightingImageFilter::SkLightingImageFilter(SkReadBuffer& buffer) 947 : INHERITED(1, buffer) { 948 fLight.reset(SkLight::UnflattenLight(buffer)); 949 fSurfaceScale = buffer.readScalar(); 950 buffer.validate(SkScalarIsFinite(fSurfaceScale)); 951 } 952 #endif 953 954 void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const { 955 this->INHERITED::flatten(buffer); 956 fLight->flattenLight(buffer); 957 buffer.writeScalar(fSurfaceScale * 255); 958 } 959 960 /////////////////////////////////////////////////////////////////////////////// 961 962 SkImageFilter* SkDiffuseLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale, 963 SkScalar kd, SkImageFilter* input, const CropRect* cropRect, uint32_t uniqueID) { 964 if (NULL == light) { 965 return NULL; 966 } 967 if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(kd)) { 968 return NULL; 969 } 970 // According to the spec, kd can be any non-negative number : 971 // http://www.w3.org/TR/SVG/filters.html#feDiffuseLightingElement 972 if (kd < 0) { 973 return NULL; 974 } 975 return SkNEW_ARGS(SkDiffuseLightingImageFilter, (light, surfaceScale, kd, input, cropRect, uniqueID)); 976 } 977 978 SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter* input, const CropRect* cropRect, uint32_t uniqueID) 979 : SkLightingImageFilter(light, surfaceScale, input, cropRect, uniqueID), 980 fKD(kd) 981 { 982 } 983 984 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 985 SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkReadBuffer& buffer) 986 : INHERITED(buffer) 987 { 988 fKD = buffer.readScalar(); 989 buffer.validate(SkScalarIsFinite(fKD) && (fKD >= 0)); 990 } 991 #endif 992 993 SkFlattenable* SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) { 994 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); 995 SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer)); 996 SkScalar surfaceScale = buffer.readScalar(); 997 SkScalar kd = buffer.readScalar(); 998 return Create(light, surfaceScale, kd, common.getInput(0), &common.cropRect(), common.uniqueID()); 999 } 1000 1001 void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const { 1002 this->INHERITED::flatten(buffer); 1003 buffer.writeScalar(fKD); 1004 } 1005 1006 bool SkDiffuseLightingImageFilter::onFilterImage(Proxy* proxy, 1007 const SkBitmap& source, 1008 const Context& ctx, 1009 SkBitmap* dst, 1010 SkIPoint* offset) const { 1011 SkImageFilter* input = getInput(0); 1012 SkBitmap src = source; 1013 SkIPoint srcOffset = SkIPoint::Make(0, 0); 1014 if (input && !input->filterImage(proxy, source, ctx, &src, &srcOffset)) { 1015 return false; 1016 } 1017 1018 if (src.colorType() != kN32_SkColorType) { 1019 return false; 1020 } 1021 SkIRect bounds; 1022 if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) { 1023 return false; 1024 } 1025 1026 if (bounds.width() < 2 || bounds.height() < 2) { 1027 return false; 1028 } 1029 1030 SkAutoLockPixels alp(src); 1031 if (!src.getPixels()) { 1032 return false; 1033 } 1034 1035 if (!dst->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) { 1036 return false; 1037 } 1038 1039 SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm())); 1040 1041 DiffuseLightingType lightingType(fKD); 1042 offset->fX = bounds.left(); 1043 offset->fY = bounds.top(); 1044 bounds.offset(-srcOffset); 1045 switch (transformedLight->type()) { 1046 case SkLight::kDistant_LightType: 1047 lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1048 break; 1049 case SkLight::kPoint_LightType: 1050 lightBitmap<DiffuseLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1051 break; 1052 case SkLight::kSpot_LightType: 1053 lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1054 break; 1055 } 1056 1057 return true; 1058 } 1059 1060 #if SK_SUPPORT_GPU 1061 bool SkDiffuseLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, 1062 GrTexture* texture, 1063 const SkMatrix& matrix, 1064 const SkIRect&) const { 1065 if (fp) { 1066 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); 1067 *fp = GrDiffuseLightingEffect::Create(texture, light(), scale, matrix, kd()); 1068 } 1069 return true; 1070 } 1071 #endif 1072 1073 /////////////////////////////////////////////////////////////////////////////// 1074 1075 SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale, 1076 SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect, uint32_t uniqueID) { 1077 if (NULL == light) { 1078 return NULL; 1079 } 1080 if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(ks) || !SkScalarIsFinite(shininess)) { 1081 return NULL; 1082 } 1083 // According to the spec, ks can be any non-negative number : 1084 // http://www.w3.org/TR/SVG/filters.html#feSpecularLightingElement 1085 if (ks < 0) { 1086 return NULL; 1087 } 1088 return SkNEW_ARGS(SkSpecularLightingImageFilter, 1089 (light, surfaceScale, ks, shininess, input, cropRect, uniqueID)); 1090 } 1091 1092 SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect, uint32_t uniqueID) 1093 : SkLightingImageFilter(light, surfaceScale, input, cropRect, uniqueID), 1094 fKS(ks), 1095 fShininess(shininess) 1096 { 1097 } 1098 1099 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 1100 SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkReadBuffer& buffer) 1101 : INHERITED(buffer) 1102 { 1103 fKS = buffer.readScalar(); 1104 fShininess = buffer.readScalar(); 1105 buffer.validate(SkScalarIsFinite(fKS) && (fKS >= 0) && 1106 SkScalarIsFinite(fShininess)); 1107 } 1108 #endif 1109 1110 SkFlattenable* SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) { 1111 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); 1112 SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer)); 1113 SkScalar surfaceScale = buffer.readScalar(); 1114 SkScalar ks = buffer.readScalar(); 1115 SkScalar shine = buffer.readScalar(); 1116 return Create(light, surfaceScale, ks, shine, common.getInput(0), &common.cropRect(), common.uniqueID()); 1117 } 1118 1119 void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const { 1120 this->INHERITED::flatten(buffer); 1121 buffer.writeScalar(fKS); 1122 buffer.writeScalar(fShininess); 1123 } 1124 1125 bool SkSpecularLightingImageFilter::onFilterImage(Proxy* proxy, 1126 const SkBitmap& source, 1127 const Context& ctx, 1128 SkBitmap* dst, 1129 SkIPoint* offset) const { 1130 SkImageFilter* input = getInput(0); 1131 SkBitmap src = source; 1132 SkIPoint srcOffset = SkIPoint::Make(0, 0); 1133 if (input && !input->filterImage(proxy, source, ctx, &src, &srcOffset)) { 1134 return false; 1135 } 1136 1137 if (src.colorType() != kN32_SkColorType) { 1138 return false; 1139 } 1140 1141 SkIRect bounds; 1142 if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) { 1143 return false; 1144 } 1145 1146 if (bounds.width() < 2 || bounds.height() < 2) { 1147 return false; 1148 } 1149 1150 SkAutoLockPixels alp(src); 1151 if (!src.getPixels()) { 1152 return false; 1153 } 1154 1155 if (!dst->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) { 1156 return false; 1157 } 1158 1159 SpecularLightingType lightingType(fKS, fShininess); 1160 offset->fX = bounds.left(); 1161 offset->fY = bounds.top(); 1162 bounds.offset(-srcOffset); 1163 SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm())); 1164 switch (transformedLight->type()) { 1165 case SkLight::kDistant_LightType: 1166 lightBitmap<SpecularLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1167 break; 1168 case SkLight::kPoint_LightType: 1169 lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1170 break; 1171 case SkLight::kSpot_LightType: 1172 lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds); 1173 break; 1174 } 1175 return true; 1176 } 1177 1178 #if SK_SUPPORT_GPU 1179 bool SkSpecularLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, 1180 GrTexture* texture, 1181 const SkMatrix& matrix, 1182 const SkIRect&) const { 1183 if (fp) { 1184 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); 1185 *fp = GrSpecularLightingEffect::Create(texture, light(), scale, matrix, ks(), shininess()); 1186 } 1187 return true; 1188 } 1189 #endif 1190 1191 /////////////////////////////////////////////////////////////////////////////// 1192 1193 #if SK_SUPPORT_GPU 1194 1195 namespace { 1196 SkPoint3 random_point3(SkRandom* random) { 1197 return SkPoint3(SkScalarToFloat(random->nextSScalar1()), 1198 SkScalarToFloat(random->nextSScalar1()), 1199 SkScalarToFloat(random->nextSScalar1())); 1200 } 1201 1202 SkLight* create_random_light(SkRandom* random) { 1203 int type = random->nextULessThan(3); 1204 switch (type) { 1205 case 0: { 1206 return SkNEW_ARGS(SkDistantLight, (random_point3(random), random->nextU())); 1207 } 1208 case 1: { 1209 return SkNEW_ARGS(SkPointLight, (random_point3(random), random->nextU())); 1210 } 1211 case 2: { 1212 return SkNEW_ARGS(SkSpotLight, (random_point3(random), 1213 random_point3(random), 1214 random->nextUScalar1(), 1215 random->nextUScalar1(), 1216 random->nextU())); 1217 } 1218 default: 1219 SkFAIL("Unexpected value."); 1220 return NULL; 1221 } 1222 } 1223 1224 } 1225 1226 class GrGLLightingEffect : public GrGLFragmentProcessor { 1227 public: 1228 GrGLLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&); 1229 virtual ~GrGLLightingEffect(); 1230 1231 virtual void emitCode(GrGLProgramBuilder*, 1232 const GrFragmentProcessor&, 1233 const GrProcessorKey&, 1234 const char* outputColor, 1235 const char* inputColor, 1236 const TransformedCoordsArray&, 1237 const TextureSamplerArray&) SK_OVERRIDE; 1238 1239 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b); 1240 1241 /** 1242 * Subclasses of GrGLLightingEffect must call INHERITED::setData(); 1243 */ 1244 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE; 1245 1246 protected: 1247 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) = 0; 1248 1249 private: 1250 typedef GrGLFragmentProcessor INHERITED; 1251 1252 UniformHandle fImageIncrementUni; 1253 UniformHandle fSurfaceScaleUni; 1254 GrGLLight* fLight; 1255 }; 1256 1257 /////////////////////////////////////////////////////////////////////////////// 1258 1259 class GrGLDiffuseLightingEffect : public GrGLLightingEffect { 1260 public: 1261 GrGLDiffuseLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&); 1262 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERRIDE; 1263 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE; 1264 1265 private: 1266 typedef GrGLLightingEffect INHERITED; 1267 1268 UniformHandle fKDUni; 1269 }; 1270 1271 /////////////////////////////////////////////////////////////////////////////// 1272 1273 class GrGLSpecularLightingEffect : public GrGLLightingEffect { 1274 public: 1275 GrGLSpecularLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&); 1276 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERRIDE; 1277 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE; 1278 1279 private: 1280 typedef GrGLLightingEffect INHERITED; 1281 1282 UniformHandle fKSUni; 1283 UniformHandle fShininessUni; 1284 }; 1285 1286 /////////////////////////////////////////////////////////////////////////////// 1287 1288 GrLightingEffect::GrLightingEffect(GrTexture* texture, 1289 const SkLight* light, 1290 SkScalar surfaceScale, 1291 const SkMatrix& matrix) 1292 : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)) 1293 , fLight(light) 1294 , fSurfaceScale(surfaceScale) 1295 , fFilterMatrix(matrix) { 1296 fLight->ref(); 1297 if (light->requiresFragmentPosition()) { 1298 this->setWillReadFragmentPosition(); 1299 } 1300 } 1301 1302 GrLightingEffect::~GrLightingEffect() { 1303 fLight->unref(); 1304 } 1305 1306 bool GrLightingEffect::onIsEqual(const GrProcessor& sBase) const { 1307 const GrLightingEffect& s = sBase.cast<GrLightingEffect>(); 1308 return this->texture(0) == s.texture(0) && 1309 fLight->isEqual(*s.fLight) && 1310 fSurfaceScale == s.fSurfaceScale; 1311 } 1312 1313 /////////////////////////////////////////////////////////////////////////////// 1314 1315 GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture, 1316 const SkLight* light, 1317 SkScalar surfaceScale, 1318 const SkMatrix& matrix, 1319 SkScalar kd) 1320 : INHERITED(texture, light, surfaceScale, matrix), fKD(kd) { 1321 } 1322 1323 const GrBackendFragmentProcessorFactory& GrDiffuseLightingEffect::getFactory() const { 1324 return GrTBackendFragmentProcessorFactory<GrDiffuseLightingEffect>::getInstance(); 1325 } 1326 1327 bool GrDiffuseLightingEffect::onIsEqual(const GrProcessor& sBase) const { 1328 const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>(); 1329 return INHERITED::onIsEqual(sBase) && 1330 this->kd() == s.kd(); 1331 } 1332 1333 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect); 1334 1335 GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(SkRandom* random, 1336 GrContext* context, 1337 const GrDrawTargetCaps&, 1338 GrTexture* textures[]) { 1339 SkScalar surfaceScale = random->nextSScalar1(); 1340 SkScalar kd = random->nextUScalar1(); 1341 SkAutoTUnref<SkLight> light(create_random_light(random)); 1342 SkMatrix matrix; 1343 for (int i = 0; i < 9; i++) { 1344 matrix[i] = random->nextUScalar1(); 1345 } 1346 return GrDiffuseLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx], 1347 light, surfaceScale, matrix, kd); 1348 } 1349 1350 1351 /////////////////////////////////////////////////////////////////////////////// 1352 1353 GrGLLightingEffect::GrGLLightingEffect(const GrBackendProcessorFactory& factory, 1354 const GrProcessor& fp) 1355 : INHERITED(factory) { 1356 const GrLightingEffect& m = fp.cast<GrLightingEffect>(); 1357 fLight = m.light()->createGLLight(); 1358 } 1359 1360 GrGLLightingEffect::~GrGLLightingEffect() { 1361 delete fLight; 1362 } 1363 1364 void GrGLLightingEffect::emitCode(GrGLProgramBuilder* builder, 1365 const GrFragmentProcessor&, 1366 const GrProcessorKey& key, 1367 const char* outputColor, 1368 const char* inputColor, 1369 const TransformedCoordsArray& coords, 1370 const TextureSamplerArray& samplers) { 1371 fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1372 kVec2f_GrSLType, 1373 "ImageIncrement"); 1374 fSurfaceScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1375 kFloat_GrSLType, 1376 "SurfaceScale"); 1377 fLight->emitLightColorUniform(builder); 1378 SkString lightFunc; 1379 this->emitLightFunc(builder, &lightFunc); 1380 static const GrGLShaderVar gSobelArgs[] = { 1381 GrGLShaderVar("a", kFloat_GrSLType), 1382 GrGLShaderVar("b", kFloat_GrSLType), 1383 GrGLShaderVar("c", kFloat_GrSLType), 1384 GrGLShaderVar("d", kFloat_GrSLType), 1385 GrGLShaderVar("e", kFloat_GrSLType), 1386 GrGLShaderVar("f", kFloat_GrSLType), 1387 GrGLShaderVar("scale", kFloat_GrSLType), 1388 }; 1389 SkString sobelFuncName; 1390 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 1391 SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0); 1392 1393 fsBuilder->emitFunction(kFloat_GrSLType, 1394 "sobel", 1395 SK_ARRAY_COUNT(gSobelArgs), 1396 gSobelArgs, 1397 "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scale;\n", 1398 &sobelFuncName); 1399 static const GrGLShaderVar gPointToNormalArgs[] = { 1400 GrGLShaderVar("x", kFloat_GrSLType), 1401 GrGLShaderVar("y", kFloat_GrSLType), 1402 GrGLShaderVar("scale", kFloat_GrSLType), 1403 }; 1404 SkString pointToNormalName; 1405 fsBuilder->emitFunction(kVec3f_GrSLType, 1406 "pointToNormal", 1407 SK_ARRAY_COUNT(gPointToNormalArgs), 1408 gPointToNormalArgs, 1409 "\treturn normalize(vec3(-x * scale, y * scale, 1));\n", 1410 &pointToNormalName); 1411 1412 static const GrGLShaderVar gInteriorNormalArgs[] = { 1413 GrGLShaderVar("m", kFloat_GrSLType, 9), 1414 GrGLShaderVar("surfaceScale", kFloat_GrSLType), 1415 }; 1416 SkString interiorNormalBody; 1417 interiorNormalBody.appendf("\treturn %s(%s(m[0], m[2], m[3], m[5], m[6], m[8], 0.25),\n" 1418 "\t %s(m[0], m[6], m[1], m[7], m[2], m[8], 0.25),\n" 1419 "\t surfaceScale);\n", 1420 pointToNormalName.c_str(), 1421 sobelFuncName.c_str(), 1422 sobelFuncName.c_str()); 1423 SkString interiorNormalName; 1424 fsBuilder->emitFunction(kVec3f_GrSLType, 1425 "interiorNormal", 1426 SK_ARRAY_COUNT(gInteriorNormalArgs), 1427 gInteriorNormalArgs, 1428 interiorNormalBody.c_str(), 1429 &interiorNormalName); 1430 1431 fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); 1432 fsBuilder->codeAppend("\t\tfloat m[9];\n"); 1433 1434 const char* imgInc = builder->getUniformCStr(fImageIncrementUni); 1435 const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni); 1436 1437 int index = 0; 1438 for (int dy = -1; dy <= 1; dy++) { 1439 for (int dx = -1; dx <= 1; dx++) { 1440 SkString texCoords; 1441 texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc); 1442 fsBuilder->codeAppendf("\t\tm[%d] = ", index++); 1443 fsBuilder->appendTextureLookup(samplers[0], texCoords.c_str()); 1444 fsBuilder->codeAppend(".a;\n"); 1445 } 1446 } 1447 fsBuilder->codeAppend("\t\tvec3 surfaceToLight = "); 1448 SkString arg; 1449 arg.appendf("%s * m[4]", surfScale); 1450 fLight->emitSurfaceToLight(builder, arg.c_str()); 1451 fsBuilder->codeAppend(";\n"); 1452 fsBuilder->codeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ", 1453 outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale); 1454 fLight->emitLightColor(builder, "surfaceToLight"); 1455 fsBuilder->codeAppend(");\n"); 1456 SkString modulate; 1457 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); 1458 fsBuilder->codeAppend(modulate.c_str()); 1459 } 1460 1461 void GrGLLightingEffect::GenKey(const GrProcessor& proc, 1462 const GrGLCaps& caps, GrProcessorKeyBuilder* b) { 1463 b->add32(proc.cast<GrLightingEffect>().light()->type()); 1464 } 1465 1466 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman, 1467 const GrProcessor& proc) { 1468 const GrLightingEffect& lighting = proc.cast<GrLightingEffect>(); 1469 GrTexture* texture = lighting.texture(0); 1470 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f; 1471 pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height()); 1472 pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale()); 1473 SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.filterMatrix())); 1474 fLight->setData(pdman, transformedLight); 1475 } 1476 1477 /////////////////////////////////////////////////////////////////////////////// 1478 1479 /////////////////////////////////////////////////////////////////////////////// 1480 1481 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendProcessorFactory& factory, 1482 const GrProcessor& proc) 1483 : INHERITED(factory, proc) { 1484 } 1485 1486 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkString* funcName) { 1487 const char* kd; 1488 fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1489 kFloat_GrSLType, 1490 "KD", 1491 &kd); 1492 1493 static const GrGLShaderVar gLightArgs[] = { 1494 GrGLShaderVar("normal", kVec3f_GrSLType), 1495 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), 1496 GrGLShaderVar("lightColor", kVec3f_GrSLType) 1497 }; 1498 SkString lightBody; 1499 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n", kd); 1500 lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n"); 1501 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, 1502 "light", 1503 SK_ARRAY_COUNT(gLightArgs), 1504 gLightArgs, 1505 lightBody.c_str(), 1506 funcName); 1507 } 1508 1509 void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman, 1510 const GrProcessor& proc) { 1511 INHERITED::setData(pdman, proc); 1512 const GrDiffuseLightingEffect& diffuse = proc.cast<GrDiffuseLightingEffect>(); 1513 pdman.set1f(fKDUni, diffuse.kd()); 1514 } 1515 1516 /////////////////////////////////////////////////////////////////////////////// 1517 1518 GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture, 1519 const SkLight* light, 1520 SkScalar surfaceScale, 1521 const SkMatrix& matrix, 1522 SkScalar ks, 1523 SkScalar shininess) 1524 : INHERITED(texture, light, surfaceScale, matrix), 1525 fKS(ks), 1526 fShininess(shininess) { 1527 } 1528 1529 const GrBackendFragmentProcessorFactory& GrSpecularLightingEffect::getFactory() const { 1530 return GrTBackendFragmentProcessorFactory<GrSpecularLightingEffect>::getInstance(); 1531 } 1532 1533 bool GrSpecularLightingEffect::onIsEqual(const GrProcessor& sBase) const { 1534 const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>(); 1535 return INHERITED::onIsEqual(sBase) && 1536 this->ks() == s.ks() && 1537 this->shininess() == s.shininess(); 1538 } 1539 1540 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect); 1541 1542 GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(SkRandom* random, 1543 GrContext* context, 1544 const GrDrawTargetCaps&, 1545 GrTexture* textures[]) { 1546 SkScalar surfaceScale = random->nextSScalar1(); 1547 SkScalar ks = random->nextUScalar1(); 1548 SkScalar shininess = random->nextUScalar1(); 1549 SkAutoTUnref<SkLight> light(create_random_light(random)); 1550 SkMatrix matrix; 1551 for (int i = 0; i < 9; i++) { 1552 matrix[i] = random->nextUScalar1(); 1553 } 1554 return GrSpecularLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx], 1555 light, surfaceScale, matrix, ks, shininess); 1556 } 1557 1558 /////////////////////////////////////////////////////////////////////////////// 1559 1560 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendProcessorFactory& factory, 1561 const GrProcessor& proc) 1562 : INHERITED(factory, proc) { 1563 } 1564 1565 void GrGLSpecularLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkString* funcName) { 1566 const char* ks; 1567 const char* shininess; 1568 1569 fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1570 kFloat_GrSLType, "KS", &ks); 1571 fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1572 kFloat_GrSLType, "Shininess", &shininess); 1573 1574 static const GrGLShaderVar gLightArgs[] = { 1575 GrGLShaderVar("normal", kVec3f_GrSLType), 1576 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), 1577 GrGLShaderVar("lightColor", kVec3f_GrSLType) 1578 }; 1579 SkString lightBody; 1580 lightBody.appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0, 0, 1)));\n"); 1581 lightBody.appendf("\tfloat colorScale = %s * pow(dot(normal, halfDir), %s);\n", ks, shininess); 1582 lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n"); 1583 lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b));\n"); 1584 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, 1585 "light", 1586 SK_ARRAY_COUNT(gLightArgs), 1587 gLightArgs, 1588 lightBody.c_str(), 1589 funcName); 1590 } 1591 1592 void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman, 1593 const GrProcessor& effect) { 1594 INHERITED::setData(pdman, effect); 1595 const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>(); 1596 pdman.set1f(fKSUni, spec.ks()); 1597 pdman.set1f(fShininessUni, spec.shininess()); 1598 } 1599 1600 /////////////////////////////////////////////////////////////////////////////// 1601 void GrGLLight::emitLightColorUniform(GrGLProgramBuilder* builder) { 1602 fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1603 kVec3f_GrSLType, "LightColor"); 1604 } 1605 1606 void GrGLLight::emitLightColor(GrGLProgramBuilder* builder, 1607 const char *surfaceToLight) { 1608 builder->getFragmentShaderBuilder()->codeAppend(builder->getUniformCStr(this->lightColorUni())); 1609 } 1610 1611 void GrGLLight::setData(const GrGLProgramDataManager& pdman, 1612 const SkLight* light) const { 1613 setUniformPoint3(pdman, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255))); 1614 } 1615 1616 /////////////////////////////////////////////////////////////////////////////// 1617 1618 void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman, 1619 const SkLight* light) const { 1620 INHERITED::setData(pdman, light); 1621 SkASSERT(light->type() == SkLight::kDistant_LightType); 1622 const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light); 1623 setUniformNormal3(pdman, fDirectionUni, distantLight->direction()); 1624 } 1625 1626 void GrGLDistantLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const char* z) { 1627 const char* dir; 1628 fDirectionUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec3f_GrSLType, 1629 "LightDirection", &dir); 1630 builder->getFragmentShaderBuilder()->codeAppend(dir); 1631 } 1632 1633 /////////////////////////////////////////////////////////////////////////////// 1634 1635 void GrGLPointLight::setData(const GrGLProgramDataManager& pdman, 1636 const SkLight* light) const { 1637 INHERITED::setData(pdman, light); 1638 SkASSERT(light->type() == SkLight::kPoint_LightType); 1639 const SkPointLight* pointLight = static_cast<const SkPointLight*>(light); 1640 setUniformPoint3(pdman, fLocationUni, pointLight->location()); 1641 } 1642 1643 void GrGLPointLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const char* z) { 1644 const char* loc; 1645 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec3f_GrSLType, 1646 "LightLocation", &loc); 1647 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 1648 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", 1649 loc, fsBuilder->fragmentPosition(), z); 1650 } 1651 1652 /////////////////////////////////////////////////////////////////////////////// 1653 1654 void GrGLSpotLight::setData(const GrGLProgramDataManager& pdman, 1655 const SkLight* light) const { 1656 INHERITED::setData(pdman, light); 1657 SkASSERT(light->type() == SkLight::kSpot_LightType); 1658 const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light); 1659 setUniformPoint3(pdman, fLocationUni, spotLight->location()); 1660 pdman.set1f(fExponentUni, spotLight->specularExponent()); 1661 pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle()); 1662 pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle()); 1663 pdman.set1f(fConeScaleUni, spotLight->coneScale()); 1664 setUniformNormal3(pdman, fSUni, spotLight->s()); 1665 } 1666 1667 void GrGLSpotLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const char* z) { 1668 const char* location; 1669 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1670 kVec3f_GrSLType, "LightLocation", &location); 1671 1672 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 1673 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", 1674 location, fsBuilder->fragmentPosition(), z); 1675 } 1676 1677 void GrGLSpotLight::emitLightColor(GrGLProgramBuilder* builder, 1678 const char *surfaceToLight) { 1679 1680 const char* color = builder->getUniformCStr(this->lightColorUni()); // created by parent class. 1681 1682 const char* exponent; 1683 const char* cosInner; 1684 const char* cosOuter; 1685 const char* coneScale; 1686 const char* s; 1687 fExponentUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1688 kFloat_GrSLType, "Exponent", &exponent); 1689 fCosInnerConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1690 kFloat_GrSLType, "CosInnerConeAngle", &cosInner); 1691 fCosOuterConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1692 kFloat_GrSLType, "CosOuterConeAngle", &cosOuter); 1693 fConeScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1694 kFloat_GrSLType, "ConeScale", &coneScale); 1695 fSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1696 kVec3f_GrSLType, "S", &s); 1697 1698 static const GrGLShaderVar gLightColorArgs[] = { 1699 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType) 1700 }; 1701 SkString lightColorBody; 1702 lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s); 1703 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter); 1704 lightColorBody.appendf("\t\treturn vec3(0);\n"); 1705 lightColorBody.appendf("\t}\n"); 1706 lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent); 1707 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner); 1708 lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n", 1709 color, cosOuter, coneScale); 1710 lightColorBody.appendf("\t}\n"); 1711 lightColorBody.appendf("\treturn %s;\n", color); 1712 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 1713 fsBuilder->emitFunction(kVec3f_GrSLType, 1714 "lightColor", 1715 SK_ARRAY_COUNT(gLightColorArgs), 1716 gLightColorArgs, 1717 lightColorBody.c_str(), 1718 &fLightColorFunc); 1719 1720 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); 1721 } 1722 1723 #endif 1724 1725 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) 1726 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) 1727 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) 1728 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END 1729
