OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The Android Open Source Project | 2 * Copyright 2012 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkLightingImageFilter.h" | 8 #include "SkLightingImageFilter.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkReadBuffer.h" | 11 #include "SkReadBuffer.h" |
12 #include "SkWriteBuffer.h" | 12 #include "SkWriteBuffer.h" |
13 #include "SkReadBuffer.h" | 13 #include "SkReadBuffer.h" |
14 #include "SkWriteBuffer.h" | 14 #include "SkWriteBuffer.h" |
15 #include "SkTypes.h" | 15 #include "SkTypes.h" |
16 | 16 |
17 #if SK_SUPPORT_GPU | 17 #if SK_SUPPORT_GPU |
18 #include "effects/GrSingleTextureEffect.h" | 18 #include "effects/GrSingleTextureEffect.h" |
19 #include "gl/GrGLEffect.h" | 19 #include "gl/GrGLEffect.h" |
20 #include "gl/GrGLShaderBuilder.h" | 20 #include "gl/builders/GrGLProgramBuilder.h" |
21 #include "GrEffect.h" | 21 #include "GrEffect.h" |
22 #include "GrTBackendEffectFactory.h" | 22 #include "GrTBackendEffectFactory.h" |
23 | 23 |
24 class GrGLDiffuseLightingEffect; | 24 class GrGLDiffuseLightingEffect; |
25 class GrGLSpecularLightingEffect; | 25 class GrGLSpecularLightingEffect; |
26 | 26 |
27 // For brevity | 27 // For brevity |
28 typedef GrGLProgramDataManager::UniformHandle UniformHandle; | 28 typedef GrGLProgramDataManager::UniformHandle UniformHandle; |
29 #endif | 29 #endif |
30 | 30 |
(...skipping 394 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
425 /////////////////////////////////////////////////////////////////////////////// | 425 /////////////////////////////////////////////////////////////////////////////// |
426 | 426 |
427 class GrGLLight { | 427 class GrGLLight { |
428 public: | 428 public: |
429 virtual ~GrGLLight() {} | 429 virtual ~GrGLLight() {} |
430 | 430 |
431 /** | 431 /** |
432 * This is called by GrGLLightingEffect::emitCode() before either of the two
virtual functions | 432 * This is called by GrGLLightingEffect::emitCode() before either of the two
virtual functions |
433 * below. It adds a vec3f uniform visible in the FS that represents the cons
tant light color. | 433 * below. It adds a vec3f uniform visible in the FS that represents the cons
tant light color. |
434 */ | 434 */ |
435 void emitLightColorUniform(GrGLShaderBuilder*); | 435 void emitLightColorUniform(GrGLProgramBuilder*); |
436 | 436 |
437 /** | 437 /** |
438 * These two functions are called from GrGLLightingEffect's emitCode() funct
ion. | 438 * These two functions are called from GrGLLightingEffect's emitCode() funct
ion. |
439 * emitSurfaceToLight places an expression in param out that is the vector f
rom the surface to | 439 * emitSurfaceToLight places an expression in param out that is the vector f
rom the surface to |
440 * the light. The expression will be used in the FS. emitLightColor writes a
n expression into | 440 * the light. The expression will be used in the FS. emitLightColor writes a
n expression into |
441 * the FS that is the color of the light. Either function may add functions
and/or uniforms to | 441 * the FS that is the color of the light. Either function may add functions
and/or uniforms to |
442 * the FS. The default of emitLightColor appends the name of the constant li
ght color uniform | 442 * the FS. The default of emitLightColor appends the name of the constant li
ght color uniform |
443 * and so this function only needs to be overridden if the light color varie
s spatially. | 443 * and so this function only needs to be overridden if the light color varie
s spatially. |
444 */ | 444 */ |
445 virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) = 0; | 445 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) = 0; |
446 virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight); | 446 virtual void emitLightColor(GrGLProgramBuilder*, const char *surfaceToLight)
; |
447 | 447 |
448 // This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLig
ht must call | 448 // This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLig
ht must call |
449 // INHERITED::setData(). | 449 // INHERITED::setData(). |
450 virtual void setData(const GrGLProgramDataManager&, | 450 virtual void setData(const GrGLProgramDataManager&, |
451 const SkLight* light) const; | 451 const SkLight* light) const; |
452 | 452 |
453 protected: | 453 protected: |
454 /** | 454 /** |
455 * Gets the constant light color uniform. Subclasses can use this in their e
mitLightColor | 455 * Gets the constant light color uniform. Subclasses can use this in their e
mitLightColor |
456 * function. | 456 * function. |
457 */ | 457 */ |
458 UniformHandle lightColorUni() const { return fColorUni; } | 458 UniformHandle lightColorUni() const { return fColorUni; } |
459 | 459 |
460 private: | 460 private: |
461 UniformHandle fColorUni; | 461 UniformHandle fColorUni; |
462 | 462 |
463 typedef SkRefCnt INHERITED; | 463 typedef SkRefCnt INHERITED; |
464 }; | 464 }; |
465 | 465 |
466 /////////////////////////////////////////////////////////////////////////////// | 466 /////////////////////////////////////////////////////////////////////////////// |
467 | 467 |
468 class GrGLDistantLight : public GrGLLight { | 468 class GrGLDistantLight : public GrGLLight { |
469 public: | 469 public: |
470 virtual ~GrGLDistantLight() {} | 470 virtual ~GrGLDistantLight() {} |
471 virtual void setData(const GrGLProgramDataManager&, | 471 virtual void setData(const GrGLProgramDataManager&, |
472 const SkLight* light) const SK_OVERRIDE; | 472 const SkLight* light) const SK_OVERRIDE; |
473 virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRI
DE; | 473 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERR
IDE; |
474 | 474 |
475 private: | 475 private: |
476 typedef GrGLLight INHERITED; | 476 typedef GrGLLight INHERITED; |
477 UniformHandle fDirectionUni; | 477 UniformHandle fDirectionUni; |
478 }; | 478 }; |
479 | 479 |
480 /////////////////////////////////////////////////////////////////////////////// | 480 /////////////////////////////////////////////////////////////////////////////// |
481 | 481 |
482 class GrGLPointLight : public GrGLLight { | 482 class GrGLPointLight : public GrGLLight { |
483 public: | 483 public: |
484 virtual ~GrGLPointLight() {} | 484 virtual ~GrGLPointLight() {} |
485 virtual void setData(const GrGLProgramDataManager&, | 485 virtual void setData(const GrGLProgramDataManager&, |
486 const SkLight* light) const SK_OVERRIDE; | 486 const SkLight* light) const SK_OVERRIDE; |
487 virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRI
DE; | 487 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERR
IDE; |
488 | 488 |
489 private: | 489 private: |
490 typedef GrGLLight INHERITED; | 490 typedef GrGLLight INHERITED; |
491 UniformHandle fLocationUni; | 491 UniformHandle fLocationUni; |
492 }; | 492 }; |
493 | 493 |
494 /////////////////////////////////////////////////////////////////////////////// | 494 /////////////////////////////////////////////////////////////////////////////// |
495 | 495 |
496 class GrGLSpotLight : public GrGLLight { | 496 class GrGLSpotLight : public GrGLLight { |
497 public: | 497 public: |
498 virtual ~GrGLSpotLight() {} | 498 virtual ~GrGLSpotLight() {} |
499 virtual void setData(const GrGLProgramDataManager&, | 499 virtual void setData(const GrGLProgramDataManager&, |
500 const SkLight* light) const SK_OVERRIDE; | 500 const SkLight* light) const SK_OVERRIDE; |
501 virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRI
DE; | 501 virtual void emitSurfaceToLight(GrGLProgramBuilder*, const char* z) SK_OVERR
IDE; |
502 virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight)
SK_OVERRIDE; | 502 virtual void emitLightColor(GrGLProgramBuilder*, const char *surfaceToLight)
SK_OVERRIDE; |
503 | 503 |
504 private: | 504 private: |
505 typedef GrGLLight INHERITED; | 505 typedef GrGLLight INHERITED; |
506 | 506 |
507 SkString fLightColorFunc; | 507 SkString fLightColorFunc; |
508 UniformHandle fLocationUni; | 508 UniformHandle fLocationUni; |
509 UniformHandle fExponentUni; | 509 UniformHandle fExponentUni; |
510 UniformHandle fCosOuterConeAngleUni; | 510 UniformHandle fCosOuterConeAngleUni; |
511 UniformHandle fCosInnerConeAngleUni; | 511 UniformHandle fCosInnerConeAngleUni; |
512 UniformHandle fConeScaleUni; | 512 UniformHandle fConeScaleUni; |
(...skipping 686 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1199 } | 1199 } |
1200 | 1200 |
1201 } | 1201 } |
1202 | 1202 |
1203 class GrGLLightingEffect : public GrGLEffect { | 1203 class GrGLLightingEffect : public GrGLEffect { |
1204 public: | 1204 public: |
1205 GrGLLightingEffect(const GrBackendEffectFactory& factory, | 1205 GrGLLightingEffect(const GrBackendEffectFactory& factory, |
1206 const GrDrawEffect& effect); | 1206 const GrDrawEffect& effect); |
1207 virtual ~GrGLLightingEffect(); | 1207 virtual ~GrGLLightingEffect(); |
1208 | 1208 |
1209 virtual void emitCode(GrGLShaderBuilder*, | 1209 virtual void emitCode(GrGLProgramBuilder*, |
1210 const GrDrawEffect&, | 1210 const GrDrawEffect&, |
1211 const GrEffectKey&, | 1211 const GrEffectKey&, |
1212 const char* outputColor, | 1212 const char* outputColor, |
1213 const char* inputColor, | 1213 const char* inputColor, |
1214 const TransformedCoordsArray&, | 1214 const TransformedCoordsArray&, |
1215 const TextureSamplerArray&) SK_OVERRIDE; | 1215 const TextureSamplerArray&) SK_OVERRIDE; |
1216 | 1216 |
1217 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder* b); | 1217 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder* b); |
1218 | 1218 |
1219 /** | 1219 /** |
1220 * Subclasses of GrGLLightingEffect must call INHERITED::setData(); | 1220 * Subclasses of GrGLLightingEffect must call INHERITED::setData(); |
1221 */ | 1221 */ |
1222 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; | 1222 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
1223 | 1223 |
1224 protected: | 1224 protected: |
1225 virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) = 0; | 1225 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) = 0; |
1226 | 1226 |
1227 private: | 1227 private: |
1228 typedef GrGLEffect INHERITED; | 1228 typedef GrGLEffect INHERITED; |
1229 | 1229 |
1230 UniformHandle fImageIncrementUni; | 1230 UniformHandle fImageIncrementUni; |
1231 UniformHandle fSurfaceScaleUni; | 1231 UniformHandle fSurfaceScaleUni; |
1232 GrGLLight* fLight; | 1232 GrGLLight* fLight; |
1233 }; | 1233 }; |
1234 | 1234 |
1235 /////////////////////////////////////////////////////////////////////////////// | 1235 /////////////////////////////////////////////////////////////////////////////// |
1236 | 1236 |
1237 class GrGLDiffuseLightingEffect : public GrGLLightingEffect { | 1237 class GrGLDiffuseLightingEffect : public GrGLLightingEffect { |
1238 public: | 1238 public: |
1239 GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory, | 1239 GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory, |
1240 const GrDrawEffect& drawEffect); | 1240 const GrDrawEffect& drawEffect); |
1241 virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRI
DE; | 1241 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; |
1242 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; | 1242 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
1243 | 1243 |
1244 private: | 1244 private: |
1245 typedef GrGLLightingEffect INHERITED; | 1245 typedef GrGLLightingEffect INHERITED; |
1246 | 1246 |
1247 UniformHandle fKDUni; | 1247 UniformHandle fKDUni; |
1248 }; | 1248 }; |
1249 | 1249 |
1250 /////////////////////////////////////////////////////////////////////////////// | 1250 /////////////////////////////////////////////////////////////////////////////// |
1251 | 1251 |
1252 class GrGLSpecularLightingEffect : public GrGLLightingEffect { | 1252 class GrGLSpecularLightingEffect : public GrGLLightingEffect { |
1253 public: | 1253 public: |
1254 GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory, | 1254 GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory, |
1255 const GrDrawEffect& effect); | 1255 const GrDrawEffect& effect); |
1256 virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRI
DE; | 1256 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; |
1257 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; | 1257 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
1258 | 1258 |
1259 private: | 1259 private: |
1260 typedef GrGLLightingEffect INHERITED; | 1260 typedef GrGLLightingEffect INHERITED; |
1261 | 1261 |
1262 UniformHandle fKSUni; | 1262 UniformHandle fKSUni; |
1263 UniformHandle fShininessUni; | 1263 UniformHandle fShininessUni; |
1264 }; | 1264 }; |
1265 | 1265 |
1266 /////////////////////////////////////////////////////////////////////////////// | 1266 /////////////////////////////////////////////////////////////////////////////// |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1334 const GrDrawEffect& drawEffect) | 1334 const GrDrawEffect& drawEffect) |
1335 : INHERITED(factory) { | 1335 : INHERITED(factory) { |
1336 const GrLightingEffect& m = drawEffect.castEffect<GrLightingEffect>(); | 1336 const GrLightingEffect& m = drawEffect.castEffect<GrLightingEffect>(); |
1337 fLight = m.light()->createGLLight(); | 1337 fLight = m.light()->createGLLight(); |
1338 } | 1338 } |
1339 | 1339 |
1340 GrGLLightingEffect::~GrGLLightingEffect() { | 1340 GrGLLightingEffect::~GrGLLightingEffect() { |
1341 delete fLight; | 1341 delete fLight; |
1342 } | 1342 } |
1343 | 1343 |
1344 void GrGLLightingEffect::emitCode(GrGLShaderBuilder* builder, | 1344 void GrGLLightingEffect::emitCode(GrGLProgramBuilder* builder, |
1345 const GrDrawEffect&, | 1345 const GrDrawEffect&, |
1346 const GrEffectKey& key, | 1346 const GrEffectKey& key, |
1347 const char* outputColor, | 1347 const char* outputColor, |
1348 const char* inputColor, | 1348 const char* inputColor, |
1349 const TransformedCoordsArray& coords, | 1349 const TransformedCoordsArray& coords, |
1350 const TextureSamplerArray& samplers) { | 1350 const TextureSamplerArray& samplers) { |
1351 SkString coords2D = builder->ensureFSCoords2D(coords, 0); | 1351 fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visib
ility, |
1352 | |
1353 fImageIncrementUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibi
lity, | |
1354 kVec2f_GrSLType, | 1352 kVec2f_GrSLType, |
1355 "ImageIncrement"); | 1353 "ImageIncrement"); |
1356 fSurfaceScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibili
ty, | 1354 fSurfaceScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibil
ity, |
1357 kFloat_GrSLType, | 1355 kFloat_GrSLType, |
1358 "SurfaceScale"); | 1356 "SurfaceScale"); |
1359 fLight->emitLightColorUniform(builder); | 1357 fLight->emitLightColorUniform(builder); |
1360 SkString lightFunc; | 1358 SkString lightFunc; |
1361 this->emitLightFunc(builder, &lightFunc); | 1359 this->emitLightFunc(builder, &lightFunc); |
1362 static const GrGLShaderVar gSobelArgs[] = { | 1360 static const GrGLShaderVar gSobelArgs[] = { |
1363 GrGLShaderVar("a", kFloat_GrSLType), | 1361 GrGLShaderVar("a", kFloat_GrSLType), |
1364 GrGLShaderVar("b", kFloat_GrSLType), | 1362 GrGLShaderVar("b", kFloat_GrSLType), |
1365 GrGLShaderVar("c", kFloat_GrSLType), | 1363 GrGLShaderVar("c", kFloat_GrSLType), |
1366 GrGLShaderVar("d", kFloat_GrSLType), | 1364 GrGLShaderVar("d", kFloat_GrSLType), |
1367 GrGLShaderVar("e", kFloat_GrSLType), | 1365 GrGLShaderVar("e", kFloat_GrSLType), |
1368 GrGLShaderVar("f", kFloat_GrSLType), | 1366 GrGLShaderVar("f", kFloat_GrSLType), |
1369 GrGLShaderVar("scale", kFloat_GrSLType), | 1367 GrGLShaderVar("scale", kFloat_GrSLType), |
1370 }; | 1368 }; |
1371 SkString sobelFuncName; | 1369 SkString sobelFuncName; |
1372 builder->fsEmitFunction(kFloat_GrSLType, | 1370 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 1371 SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0); |
| 1372 |
| 1373 fsBuilder->emitFunction(kFloat_GrSLType, |
1373 "sobel", | 1374 "sobel", |
1374 SK_ARRAY_COUNT(gSobelArgs), | 1375 SK_ARRAY_COUNT(gSobelArgs), |
1375 gSobelArgs, | 1376 gSobelArgs, |
1376 "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scal
e;\n", | 1377 "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scal
e;\n", |
1377 &sobelFuncName); | 1378 &sobelFuncName); |
1378 static const GrGLShaderVar gPointToNormalArgs[] = { | 1379 static const GrGLShaderVar gPointToNormalArgs[] = { |
1379 GrGLShaderVar("x", kFloat_GrSLType), | 1380 GrGLShaderVar("x", kFloat_GrSLType), |
1380 GrGLShaderVar("y", kFloat_GrSLType), | 1381 GrGLShaderVar("y", kFloat_GrSLType), |
1381 GrGLShaderVar("scale", kFloat_GrSLType), | 1382 GrGLShaderVar("scale", kFloat_GrSLType), |
1382 }; | 1383 }; |
1383 SkString pointToNormalName; | 1384 SkString pointToNormalName; |
1384 builder->fsEmitFunction(kVec3f_GrSLType, | 1385 fsBuilder->emitFunction(kVec3f_GrSLType, |
1385 "pointToNormal", | 1386 "pointToNormal", |
1386 SK_ARRAY_COUNT(gPointToNormalArgs), | 1387 SK_ARRAY_COUNT(gPointToNormalArgs), |
1387 gPointToNormalArgs, | 1388 gPointToNormalArgs, |
1388 "\treturn normalize(vec3(-x * scale, y * scale, 1));
\n", | 1389 "\treturn normalize(vec3(-x * scale, y * scale, 1));
\n", |
1389 &pointToNormalName); | 1390 &pointToNormalName); |
1390 | 1391 |
1391 static const GrGLShaderVar gInteriorNormalArgs[] = { | 1392 static const GrGLShaderVar gInteriorNormalArgs[] = { |
1392 GrGLShaderVar("m", kFloat_GrSLType, 9), | 1393 GrGLShaderVar("m", kFloat_GrSLType, 9), |
1393 GrGLShaderVar("surfaceScale", kFloat_GrSLType), | 1394 GrGLShaderVar("surfaceScale", kFloat_GrSLType), |
1394 }; | 1395 }; |
1395 SkString interiorNormalBody; | 1396 SkString interiorNormalBody; |
1396 interiorNormalBody.appendf("\treturn %s(%s(m[0], m[2], m[3], m[5], m[6], m[8
], 0.25),\n" | 1397 interiorNormalBody.appendf("\treturn %s(%s(m[0], m[2], m[3], m[5], m[6], m[8
], 0.25),\n" |
1397 "\t %s(m[0], m[6], m[1], m[7], m[2], m[8],
0.25),\n" | 1398 "\t %s(m[0], m[6], m[1], m[7], m[2], m[8],
0.25),\n" |
1398 "\t surfaceScale);\n", | 1399 "\t surfaceScale);\n", |
1399 pointToNormalName.c_str(), | 1400 pointToNormalName.c_str(), |
1400 sobelFuncName.c_str(), | 1401 sobelFuncName.c_str(), |
1401 sobelFuncName.c_str()); | 1402 sobelFuncName.c_str()); |
1402 SkString interiorNormalName; | 1403 SkString interiorNormalName; |
1403 builder->fsEmitFunction(kVec3f_GrSLType, | 1404 fsBuilder->emitFunction(kVec3f_GrSLType, |
1404 "interiorNormal", | 1405 "interiorNormal", |
1405 SK_ARRAY_COUNT(gInteriorNormalArgs), | 1406 SK_ARRAY_COUNT(gInteriorNormalArgs), |
1406 gInteriorNormalArgs, | 1407 gInteriorNormalArgs, |
1407 interiorNormalBody.c_str(), | 1408 interiorNormalBody.c_str(), |
1408 &interiorNormalName); | 1409 &interiorNormalName); |
1409 | 1410 |
1410 builder->fsCodeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); | 1411 fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); |
1411 builder->fsCodeAppend("\t\tfloat m[9];\n"); | 1412 fsBuilder->codeAppend("\t\tfloat m[9];\n"); |
1412 | 1413 |
1413 const char* imgInc = builder->getUniformCStr(fImageIncrementUni); | 1414 const char* imgInc = builder->getUniformCStr(fImageIncrementUni); |
1414 const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni); | 1415 const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni); |
1415 | 1416 |
1416 int index = 0; | 1417 int index = 0; |
1417 for (int dy = -1; dy <= 1; dy++) { | 1418 for (int dy = -1; dy <= 1; dy++) { |
1418 for (int dx = -1; dx <= 1; dx++) { | 1419 for (int dx = -1; dx <= 1; dx++) { |
1419 SkString texCoords; | 1420 SkString texCoords; |
1420 texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc); | 1421 texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc); |
1421 builder->fsCodeAppendf("\t\tm[%d] = ", index++); | 1422 fsBuilder->codeAppendf("\t\tm[%d] = ", index++); |
1422 builder->fsAppendTextureLookup(samplers[0], texCoords.c_str()); | 1423 fsBuilder->appendTextureLookup(samplers[0], texCoords.c_str()); |
1423 builder->fsCodeAppend(".a;\n"); | 1424 fsBuilder->codeAppend(".a;\n"); |
1424 } | 1425 } |
1425 } | 1426 } |
1426 builder->fsCodeAppend("\t\tvec3 surfaceToLight = "); | 1427 fsBuilder->codeAppend("\t\tvec3 surfaceToLight = "); |
1427 SkString arg; | 1428 SkString arg; |
1428 arg.appendf("%s * m[4]", surfScale); | 1429 arg.appendf("%s * m[4]", surfScale); |
1429 fLight->emitSurfaceToLight(builder, arg.c_str()); | 1430 fLight->emitSurfaceToLight(builder, arg.c_str()); |
1430 builder->fsCodeAppend(";\n"); | 1431 fsBuilder->codeAppend(";\n"); |
1431 builder->fsCodeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ", | 1432 fsBuilder->codeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ", |
1432 outputColor, lightFunc.c_str(), interiorNormalName.c_
str(), surfScale); | 1433 outputColor, lightFunc.c_str(), interiorNormalName.c_
str(), surfScale); |
1433 fLight->emitLightColor(builder, "surfaceToLight"); | 1434 fLight->emitLightColor(builder, "surfaceToLight"); |
1434 builder->fsCodeAppend(");\n"); | 1435 fsBuilder->codeAppend(");\n"); |
1435 SkString modulate; | 1436 SkString modulate; |
1436 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); | 1437 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); |
1437 builder->fsCodeAppend(modulate.c_str()); | 1438 fsBuilder->codeAppend(modulate.c_str()); |
1438 } | 1439 } |
1439 | 1440 |
1440 void GrGLLightingEffect::GenKey(const GrDrawEffect& drawEffect, | 1441 void GrGLLightingEffect::GenKey(const GrDrawEffect& drawEffect, |
1441 const GrGLCaps& caps, GrEffectKeyBuilder* b) { | 1442 const GrGLCaps& caps, GrEffectKeyBuilder* b) { |
1442 b->add32(drawEffect.castEffect<GrLightingEffect>().light()->type()); | 1443 b->add32(drawEffect.castEffect<GrLightingEffect>().light()->type()); |
1443 } | 1444 } |
1444 | 1445 |
1445 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1446 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1446 const GrDrawEffect& drawEffect) { | 1447 const GrDrawEffect& drawEffect) { |
1447 const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>()
; | 1448 const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>()
; |
1448 GrTexture* texture = lighting.texture(0); | 1449 GrTexture* texture = lighting.texture(0); |
1449 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f; | 1450 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f; |
1450 pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->he
ight()); | 1451 pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->he
ight()); |
1451 pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale()); | 1452 pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale()); |
1452 SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.
filterMatrix())); | 1453 SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.
filterMatrix())); |
1453 fLight->setData(pdman, transformedLight); | 1454 fLight->setData(pdman, transformedLight); |
1454 } | 1455 } |
1455 | 1456 |
1456 /////////////////////////////////////////////////////////////////////////////// | 1457 /////////////////////////////////////////////////////////////////////////////// |
1457 | 1458 |
1458 /////////////////////////////////////////////////////////////////////////////// | 1459 /////////////////////////////////////////////////////////////////////////////// |
1459 | 1460 |
1460 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactor
y& factory, | 1461 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactor
y& factory, |
1461 const GrDrawEffect& drawEff
ect) | 1462 const GrDrawEffect& drawEff
ect) |
1462 : INHERITED(factory, drawEffect) { | 1463 : INHERITED(factory, drawEffect) { |
1463 } | 1464 } |
1464 | 1465 |
1465 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStri
ng* funcName) { | 1466 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkStr
ing* funcName) { |
1466 const char* kd; | 1467 const char* kd; |
1467 fKDUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1468 fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1468 kFloat_GrSLType, | 1469 kFloat_GrSLType, |
1469 "KD", | 1470 "KD", |
1470 &kd); | 1471 &kd); |
1471 | 1472 |
1472 static const GrGLShaderVar gLightArgs[] = { | 1473 static const GrGLShaderVar gLightArgs[] = { |
1473 GrGLShaderVar("normal", kVec3f_GrSLType), | 1474 GrGLShaderVar("normal", kVec3f_GrSLType), |
1474 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), | 1475 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), |
1475 GrGLShaderVar("lightColor", kVec3f_GrSLType) | 1476 GrGLShaderVar("lightColor", kVec3f_GrSLType) |
1476 }; | 1477 }; |
1477 SkString lightBody; | 1478 SkString lightBody; |
1478 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); | 1479 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); |
1479 lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1
.0);\n"); | 1480 lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1
.0);\n"); |
1480 builder->fsEmitFunction(kVec4f_GrSLType, | 1481 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, |
1481 "light", | 1482 "light", |
1482 SK_ARRAY_COUNT(gLightArgs), | 1483 SK_ARRAY_COUNT(gLightArgs)
, |
1483 gLightArgs, | 1484 gLightArgs, |
1484 lightBody.c_str(), | 1485 lightBody.c_str(), |
1485 funcName); | 1486 funcName); |
1486 } | 1487 } |
1487 | 1488 |
1488 void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1489 void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1489 const GrDrawEffect& drawEffect) { | 1490 const GrDrawEffect& drawEffect) { |
1490 INHERITED::setData(pdman, drawEffect); | 1491 INHERITED::setData(pdman, drawEffect); |
1491 const GrDiffuseLightingEffect& diffuse = drawEffect.castEffect<GrDiffuseLigh
tingEffect>(); | 1492 const GrDiffuseLightingEffect& diffuse = drawEffect.castEffect<GrDiffuseLigh
tingEffect>(); |
1492 pdman.set1f(fKDUni, diffuse.kd()); | 1493 pdman.set1f(fKDUni, diffuse.kd()); |
1493 } | 1494 } |
1494 | 1495 |
1495 /////////////////////////////////////////////////////////////////////////////// | 1496 /////////////////////////////////////////////////////////////////////////////// |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1534 light, surfaceScale, matrix, ks, shi
niness); | 1535 light, surfaceScale, matrix, ks, shi
niness); |
1535 } | 1536 } |
1536 | 1537 |
1537 /////////////////////////////////////////////////////////////////////////////// | 1538 /////////////////////////////////////////////////////////////////////////////// |
1538 | 1539 |
1539 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFact
ory& factory, | 1540 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFact
ory& factory, |
1540 const GrDrawEffect& drawE
ffect) | 1541 const GrDrawEffect& drawE
ffect) |
1541 : INHERITED(factory, drawEffect) { | 1542 : INHERITED(factory, drawEffect) { |
1542 } | 1543 } |
1543 | 1544 |
1544 void GrGLSpecularLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStr
ing* funcName) { | 1545 void GrGLSpecularLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkSt
ring* funcName) { |
1545 const char* ks; | 1546 const char* ks; |
1546 const char* shininess; | 1547 const char* shininess; |
1547 | 1548 |
1548 fKSUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1549 fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1549 kFloat_GrSLType, "KS", &ks); | 1550 kFloat_GrSLType, "KS", &ks); |
1550 fShininessUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1551 fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
1551 kFloat_GrSLType, "Shininess", &shininess
); | 1552 kFloat_GrSLType, "Shininess", &shininess
); |
1552 | 1553 |
1553 static const GrGLShaderVar gLightArgs[] = { | 1554 static const GrGLShaderVar gLightArgs[] = { |
1554 GrGLShaderVar("normal", kVec3f_GrSLType), | 1555 GrGLShaderVar("normal", kVec3f_GrSLType), |
1555 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), | 1556 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), |
1556 GrGLShaderVar("lightColor", kVec3f_GrSLType) | 1557 GrGLShaderVar("lightColor", kVec3f_GrSLType) |
1557 }; | 1558 }; |
1558 SkString lightBody; | 1559 SkString lightBody; |
1559 lightBody.appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0,
0, 1)));\n"); | 1560 lightBody.appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0,
0, 1)));\n"); |
1560 lightBody.appendf("\tfloat colorScale = %s * pow(dot(normal, halfDir), %s);\
n", ks, shininess); | 1561 lightBody.appendf("\tfloat colorScale = %s * pow(dot(normal, halfDir), %s);\
n", ks, shininess); |
1561 lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\
n"); | 1562 lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\
n"); |
1562 lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b))
;\n"); | 1563 lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b))
;\n"); |
1563 builder->fsEmitFunction(kVec4f_GrSLType, | 1564 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, |
1564 "light", | 1565 "light", |
1565 SK_ARRAY_COUNT(gLightArgs), | 1566 SK_ARRAY_COUNT(gLightArgs)
, |
1566 gLightArgs, | 1567 gLightArgs, |
1567 lightBody.c_str(), | 1568 lightBody.c_str(), |
1568 funcName); | 1569 funcName); |
1569 } | 1570 } |
1570 | 1571 |
1571 void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1572 void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1572 const GrDrawEffect& drawEffect) { | 1573 const GrDrawEffect& drawEffect) { |
1573 INHERITED::setData(pdman, drawEffect); | 1574 INHERITED::setData(pdman, drawEffect); |
1574 const GrSpecularLightingEffect& spec = drawEffect.castEffect<GrSpecularLight
ingEffect>(); | 1575 const GrSpecularLightingEffect& spec = drawEffect.castEffect<GrSpecularLight
ingEffect>(); |
1575 pdman.set1f(fKSUni, spec.ks()); | 1576 pdman.set1f(fKSUni, spec.ks()); |
1576 pdman.set1f(fShininessUni, spec.shininess()); | 1577 pdman.set1f(fShininessUni, spec.shininess()); |
1577 } | 1578 } |
1578 | 1579 |
1579 /////////////////////////////////////////////////////////////////////////////// | 1580 /////////////////////////////////////////////////////////////////////////////// |
1580 void GrGLLight::emitLightColorUniform(GrGLShaderBuilder* builder) { | 1581 void GrGLLight::emitLightColorUniform(GrGLProgramBuilder* builder) { |
1581 fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1582 fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1582 kVec3f_GrSLType, "LightColor"); | 1583 kVec3f_GrSLType, "LightColor"); |
1583 } | 1584 } |
1584 | 1585 |
1585 void GrGLLight::emitLightColor(GrGLShaderBuilder* builder, | 1586 void GrGLLight::emitLightColor(GrGLProgramBuilder* builder, |
1586 const char *surfaceToLight) { | 1587 const char *surfaceToLight) { |
1587 builder->fsCodeAppend(builder->getUniformCStr(this->lightColorUni())); | 1588 builder->getFragmentShaderBuilder()-> |
| 1589 codeAppend(builder->getUniformCStr(this->lightColorUni())); |
1588 } | 1590 } |
1589 | 1591 |
1590 void GrGLLight::setData(const GrGLProgramDataManager& pdman, | 1592 void GrGLLight::setData(const GrGLProgramDataManager& pdman, |
1591 const SkLight* light) const { | 1593 const SkLight* light) const { |
1592 setUniformPoint3(pdman, fColorUni, light->color() * SkScalarInvert(SkIntToSc
alar(255))); | 1594 setUniformPoint3(pdman, fColorUni, light->color() * SkScalarInvert(SkIntToSc
alar(255))); |
1593 } | 1595 } |
1594 | 1596 |
1595 /////////////////////////////////////////////////////////////////////////////// | 1597 /////////////////////////////////////////////////////////////////////////////// |
1596 | 1598 |
1597 void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman, | 1599 void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman, |
1598 const SkLight* light) const { | 1600 const SkLight* light) const { |
1599 INHERITED::setData(pdman, light); | 1601 INHERITED::setData(pdman, light); |
1600 SkASSERT(light->type() == SkLight::kDistant_LightType); | 1602 SkASSERT(light->type() == SkLight::kDistant_LightType); |
1601 const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(ligh
t); | 1603 const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(ligh
t); |
1602 setUniformNormal3(pdman, fDirectionUni, distantLight->direction()); | 1604 setUniformNormal3(pdman, fDirectionUni, distantLight->direction()); |
1603 } | 1605 } |
1604 | 1606 |
1605 void GrGLDistantLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char
* z) { | 1607 void GrGLDistantLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const cha
r* z) { |
1606 const char* dir; | 1608 const char* dir; |
1607 fDirectionUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
kVec3f_GrSLType, | 1609 fDirectionUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, kVec3f_GrSLType, |
1608 "LightDirection", &dir); | 1610 "LightDirection", &dir); |
1609 builder->fsCodeAppend(dir); | 1611 builder->getFragmentShaderBuilder()->codeAppend(dir); |
1610 } | 1612 } |
1611 | 1613 |
1612 /////////////////////////////////////////////////////////////////////////////// | 1614 /////////////////////////////////////////////////////////////////////////////// |
1613 | 1615 |
1614 void GrGLPointLight::setData(const GrGLProgramDataManager& pdman, | 1616 void GrGLPointLight::setData(const GrGLProgramDataManager& pdman, |
1615 const SkLight* light) const { | 1617 const SkLight* light) const { |
1616 INHERITED::setData(pdman, light); | 1618 INHERITED::setData(pdman, light); |
1617 SkASSERT(light->type() == SkLight::kPoint_LightType); | 1619 SkASSERT(light->type() == SkLight::kPoint_LightType); |
1618 const SkPointLight* pointLight = static_cast<const SkPointLight*>(light); | 1620 const SkPointLight* pointLight = static_cast<const SkPointLight*>(light); |
1619 setUniformPoint3(pdman, fLocationUni, pointLight->location()); | 1621 setUniformPoint3(pdman, fLocationUni, pointLight->location()); |
1620 } | 1622 } |
1621 | 1623 |
1622 void GrGLPointLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char*
z) { | 1624 void GrGLPointLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const char*
z) { |
1623 const char* loc; | 1625 const char* loc; |
1624 fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
kVec3f_GrSLType, | 1626 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, |
1625 "LightLocation", &loc); | 1627 "LightLocation", &loc); |
1626 builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))", loc, builder->frag
mentPosition(), z); | 1628 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 1629 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", |
| 1630 loc, fsBuilder->fragmentPosition(), z); |
1627 } | 1631 } |
1628 | 1632 |
1629 /////////////////////////////////////////////////////////////////////////////// | 1633 /////////////////////////////////////////////////////////////////////////////// |
1630 | 1634 |
1631 void GrGLSpotLight::setData(const GrGLProgramDataManager& pdman, | 1635 void GrGLSpotLight::setData(const GrGLProgramDataManager& pdman, |
1632 const SkLight* light) const { | 1636 const SkLight* light) const { |
1633 INHERITED::setData(pdman, light); | 1637 INHERITED::setData(pdman, light); |
1634 SkASSERT(light->type() == SkLight::kSpot_LightType); | 1638 SkASSERT(light->type() == SkLight::kSpot_LightType); |
1635 const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light); | 1639 const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light); |
1636 setUniformPoint3(pdman, fLocationUni, spotLight->location()); | 1640 setUniformPoint3(pdman, fLocationUni, spotLight->location()); |
1637 pdman.set1f(fExponentUni, spotLight->specularExponent()); | 1641 pdman.set1f(fExponentUni, spotLight->specularExponent()); |
1638 pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle()); | 1642 pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle()); |
1639 pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle()); | 1643 pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle()); |
1640 pdman.set1f(fConeScaleUni, spotLight->coneScale()); | 1644 pdman.set1f(fConeScaleUni, spotLight->coneScale()); |
1641 setUniformNormal3(pdman, fSUni, spotLight->s()); | 1645 setUniformNormal3(pdman, fSUni, spotLight->s()); |
1642 } | 1646 } |
1643 | 1647 |
1644 void GrGLSpotLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z
) { | 1648 void GrGLSpotLight::emitSurfaceToLight(GrGLProgramBuilder* builder, const char*
z) { |
1645 const char* location; | 1649 const char* location; |
1646 fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1650 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1647 kVec3f_GrSLType, "LightLocation", &locati
on); | 1651 kVec3f_GrSLType, "LightLocation", &locati
on); |
1648 builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))", | 1652 |
1649 location, builder->fragmentPosition(), z); | 1653 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 1654 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", |
| 1655 location, fsBuilder->fragmentPosition(), z); |
1650 } | 1656 } |
1651 | 1657 |
1652 void GrGLSpotLight::emitLightColor(GrGLShaderBuilder* builder, | 1658 void GrGLSpotLight::emitLightColor(GrGLProgramBuilder* builder, |
1653 const char *surfaceToLight) { | 1659 const char *surfaceToLight) { |
1654 | 1660 |
1655 const char* color = builder->getUniformCStr(this->lightColorUni()); // creat
ed by parent class. | 1661 const char* color = builder->getUniformCStr(this->lightColorUni()); // creat
ed by parent class. |
1656 | 1662 |
1657 const char* exponent; | 1663 const char* exponent; |
1658 const char* cosInner; | 1664 const char* cosInner; |
1659 const char* cosOuter; | 1665 const char* cosOuter; |
1660 const char* coneScale; | 1666 const char* coneScale; |
1661 const char* s; | 1667 const char* s; |
1662 fExponentUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1668 fExponentUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1663 kFloat_GrSLType, "Exponent", &exponent); | 1669 kFloat_GrSLType, "Exponent", &exponent); |
1664 fCosInnerConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_Vis
ibility, | 1670 fCosInnerConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Vi
sibility, |
1665 kFloat_GrSLType, "CosInnerConeAn
gle", &cosInner); | 1671 kFloat_GrSLType, "CosInnerConeAn
gle", &cosInner); |
1666 fCosOuterConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_Vis
ibility, | 1672 fCosOuterConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Vi
sibility, |
1667 kFloat_GrSLType, "CosOuterConeAn
gle", &cosOuter); | 1673 kFloat_GrSLType, "CosOuterConeAn
gle", &cosOuter); |
1668 fConeScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1674 fConeScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
1669 kFloat_GrSLType, "ConeScale", &coneScale
); | 1675 kFloat_GrSLType, "ConeScale", &coneScale
); |
1670 fSUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, | 1676 fSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1671 kVec3f_GrSLType, "S", &s); | 1677 kVec3f_GrSLType, "S", &s); |
1672 | 1678 |
1673 static const GrGLShaderVar gLightColorArgs[] = { | 1679 static const GrGLShaderVar gLightColorArgs[] = { |
1674 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType) | 1680 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType) |
1675 }; | 1681 }; |
1676 SkString lightColorBody; | 1682 SkString lightColorBody; |
1677 lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s); | 1683 lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s); |
1678 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter); | 1684 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter); |
1679 lightColorBody.appendf("\t\treturn vec3(0);\n"); | 1685 lightColorBody.appendf("\t\treturn vec3(0);\n"); |
1680 lightColorBody.appendf("\t}\n"); | 1686 lightColorBody.appendf("\t}\n"); |
1681 lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent); | 1687 lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent); |
1682 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner); | 1688 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner); |
1683 lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n", | 1689 lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n", |
1684 color, cosOuter, coneScale); | 1690 color, cosOuter, coneScale); |
1685 lightColorBody.appendf("\t}\n"); | 1691 lightColorBody.appendf("\t}\n"); |
1686 lightColorBody.appendf("\treturn %s;\n", color); | 1692 lightColorBody.appendf("\treturn %s;\n", color); |
1687 builder->fsEmitFunction(kVec3f_GrSLType, | 1693 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
| 1694 fsBuilder->emitFunction(kVec3f_GrSLType, |
1688 "lightColor", | 1695 "lightColor", |
1689 SK_ARRAY_COUNT(gLightColorArgs), | 1696 SK_ARRAY_COUNT(gLightColorArgs), |
1690 gLightColorArgs, | 1697 gLightColorArgs, |
1691 lightColorBody.c_str(), | 1698 lightColorBody.c_str(), |
1692 &fLightColorFunc); | 1699 &fLightColorFunc); |
1693 | 1700 |
1694 builder->fsCodeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); | 1701 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); |
1695 } | 1702 } |
1696 | 1703 |
1697 #endif | 1704 #endif |
1698 | 1705 |
1699 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) | 1706 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) |
1700 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) | 1707 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) |
1701 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) | 1708 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) |
1702 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 1709 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |