| OLD | NEW |
|---|
| (Empty) |
| 1 | |
| 2 /* | |
| 3 * Copyright 2015 Google Inc. | |
| 4 * | |
| 5 * Use of this source code is governed by a BSD-style license that can be | |
| 6 * found in the LICENSE file. | |
| 7 */ | |
| 8 | |
| 9 #include "SkBitmapProcState.h" | |
| 10 #include "SkColor.h" | |
| 11 #include "SkEmptyShader.h" | |
| 12 #include "SkErrorInternals.h" | |
| 13 #include "SkLightingShader.h" | |
| 14 #include "SkMathPriv.h" | |
| 15 #include "SkPoint3.h" | |
| 16 #include "SkReadBuffer.h" | |
| 17 #include "SkWriteBuffer.h" | |
| 18 | |
| 19 //////////////////////////////////////////////////////////////////////////// | |
| 20 | |
| 21 /* | |
| 22 SkLightingShader TODOs: | |
| 23 support other than clamp mode | |
| 24 allow 'diffuse' & 'normal' to be of different dimensions? | |
| 25 support different light types | |
| 26 support multiple lights | |
| 27 enforce normal map is 4 channel | |
| 28 use SkImages instead if SkBitmaps | |
| 29 | |
| 30 To Test: | |
| 31 non-opaque diffuse textures | |
| 32 A8 diffuse textures | |
| 33 down & upsampled draws | |
| 34 */ | |
| 35 | |
| 36 | |
| 37 | |
| 38 /** \class SkLightingShaderImpl | |
| 39 This subclass of shader applies lighting. | |
| 40 */ | |
| 41 class SK_API SkLightingShaderImpl : public SkShader { | |
| 42 public: | |
| 43 | |
| 44 /** Create a new lighting shader that uses the provided normal map and | |
| 45 lights to light the diffuse bitmap. | |
| 46 @param diffuse the diffuse bitmap | |
| 47 @param normal the normal map | |
| 48 @param lights the lights applied to the normal map | |
| 49 @param invNormRotation rotation applied to the normal map's normals | |
| 50 @param diffLocalM the local matrix for the diffuse coordinates | |
| 51 @param normLocalM the local matrix for the normal coordinates | |
| 52 */ | |
| 53 SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal, | |
| 54 const SkLightingShader::Lights* lights, | |
| 55 const SkVector& invNormRotation, | |
| 56 const SkMatrix* diffLocalM, const SkMatrix* normLocalM)
| |
| 57 : INHERITED(diffLocalM) | |
| 58 , fDiffuseMap(diffuse) | |
| 59 , fNormalMap(normal) | |
| 60 , fLights(SkRef(lights)) | |
| 61 , fInvNormRotation(invNormRotation) { | |
| 62 | |
| 63 if (normLocalM) { | |
| 64 fNormLocalMatrix = *normLocalM; | |
| 65 } else { | |
| 66 fNormLocalMatrix.reset(); | |
| 67 } | |
| 68 // Pre-cache so future calls to fNormLocalMatrix.getType() are threadsaf
e. | |
| 69 (void)fNormLocalMatrix.getType(); | |
| 70 | |
| 71 } | |
| 72 | |
| 73 bool isOpaque() const override; | |
| 74 | |
| 75 bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& v
iewM, | |
| 76 const SkMatrix* localMatrix, GrColor* color, | |
| 77 GrProcessorDataManager*, GrFragmentProcessor** fp)
const override; | |
| 78 | |
| 79 size_t contextSize() const override; | |
| 80 | |
| 81 class LightingShaderContext : public SkShader::Context { | |
| 82 public: | |
| 83 // The context takes ownership of the states. It will call their destruc
tors | |
| 84 // but will NOT free the memory. | |
| 85 LightingShaderContext(const SkLightingShaderImpl&, const ContextRec&, | |
| 86 SkBitmapProcState* diffuseState, SkBitmapProcState
* normalState); | |
| 87 ~LightingShaderContext() override; | |
| 88 | |
| 89 void shadeSpan(int x, int y, SkPMColor[], int count) override; | |
| 90 | |
| 91 uint32_t getFlags() const override { return fFlags; } | |
| 92 | |
| 93 private: | |
| 94 SkBitmapProcState* fDiffuseState; | |
| 95 SkBitmapProcState* fNormalState; | |
| 96 uint32_t fFlags; | |
| 97 | |
| 98 typedef SkShader::Context INHERITED; | |
| 99 }; | |
| 100 | |
| 101 SK_TO_STRING_OVERRIDE() | |
| 102 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingShaderImpl) | |
| 103 | |
| 104 protected: | |
| 105 void flatten(SkWriteBuffer&) const override; | |
| 106 Context* onCreateContext(const ContextRec&, void*) const override; | |
| 107 bool computeNormTotalInverse(const ContextRec& rec, SkMatrix* normTotalInver
se) const; | |
| 108 | |
| 109 private: | |
| 110 SkBitmap fDiffuseMap; | |
| 111 SkBitmap fNormalMap; | |
| 112 | |
| 113 SkAutoTUnref<const SkLightingShader::Lights> fLights; | |
| 114 | |
| 115 SkMatrix fNormLocalMatrix; | |
| 116 SkVector fInvNormRotation; | |
| 117 | |
| 118 friend class SkLightingShader; | |
| 119 | |
| 120 typedef SkShader INHERITED; | |
| 121 }; | |
| 122 | |
| 123 //////////////////////////////////////////////////////////////////////////// | |
| 124 | |
| 125 #if SK_SUPPORT_GPU | |
| 126 | |
| 127 #include "GrCoordTransform.h" | |
| 128 #include "GrFragmentProcessor.h" | |
| 129 #include "GrTextureAccess.h" | |
| 130 #include "gl/GrGLProcessor.h" | |
| 131 #include "gl/builders/GrGLProgramBuilder.h" | |
| 132 #include "SkGr.h" | |
| 133 | |
| 134 class LightingFP : public GrFragmentProcessor { | |
| 135 public: | |
| 136 LightingFP(GrProcessorDataManager* pdm, GrTexture* diffuse, GrTexture* norma
l, | |
| 137 const SkMatrix& diffMatrix, const SkMatrix& normMatrix, | |
| 138 const GrTextureParams& diffParams, const GrTextureParams& normPar
ams, | |
| 139 const SkLightingShader::Lights* lights, const SkVector& invNormRo
tation) | |
| 140 : fDiffDeviceTransform(kLocal_GrCoordSet, diffMatrix, diffuse, diffParam
s.filterMode()) | |
| 141 , fNormDeviceTransform(kLocal_GrCoordSet, normMatrix, normal, normParams
.filterMode()) | |
| 142 , fDiffuseTextureAccess(diffuse, diffParams) | |
| 143 , fNormalTextureAccess(normal, normParams) | |
| 144 , fInvNormRotation(invNormRotation) { | |
| 145 this->addCoordTransform(&fDiffDeviceTransform); | |
| 146 this->addCoordTransform(&fNormDeviceTransform); | |
| 147 this->addTextureAccess(&fDiffuseTextureAccess); | |
| 148 this->addTextureAccess(&fNormalTextureAccess); | |
| 149 | |
| 150 // fuse all ambient lights into a single one | |
| 151 fAmbientColor.set(0.0f, 0.0f, 0.0f); | |
| 152 for (int i = 0; i < lights->numLights(); ++i) { | |
| 153 if (SkLight::kAmbient_LightType == lights->light(i).type()) { | |
| 154 fAmbientColor += lights->light(i).color(); | |
| 155 } else { | |
| 156 // TODO: handle more than one of these | |
| 157 fLightColor = lights->light(i).color(); | |
| 158 fLightDir = lights->light(i).dir(); | |
| 159 } | |
| 160 } | |
| 161 | |
| 162 this->initClassID<LightingFP>(); | |
| 163 } | |
| 164 | |
| 165 class LightingGLFP : public GrGLFragmentProcessor { | |
| 166 public: | |
| 167 LightingGLFP() { | |
| 168 fLightDir.fX = 10000.0f; | |
| 169 fLightColor.fX = 0.0f; | |
| 170 fAmbientColor.fX = 0.0f; | |
| 171 fInvNormRotation.fX = 0.0f; | |
| 172 } | |
| 173 | |
| 174 void emitCode(EmitArgs& args) override { | |
| 175 | |
| 176 GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder()
; | |
| 177 | |
| 178 // add uniforms | |
| 179 const char* lightDirUniName = NULL; | |
| 180 fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragme
nt_Visibility, | |
| 181 kVec3f_GrSLType, kDefault_G
rSLPrecision, | |
| 182 "LightDir", &lightDirUniNam
e); | |
| 183 | |
| 184 const char* lightColorUniName = NULL; | |
| 185 fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFrag
ment_Visibility, | |
| 186 kVec3f_GrSLType, kDefault
_GrSLPrecision, | |
| 187 "LightColor", &lightColor
UniName); | |
| 188 | |
| 189 const char* ambientColorUniName = NULL; | |
| 190 fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFr
agment_Visibility, | |
| 191 kVec3f_GrSLType, kDefau
lt_GrSLPrecision, | |
| 192 "AmbientColor", &ambien
tColorUniName); | |
| 193 | |
| 194 const char* xformUniName = NULL; | |
| 195 fXformUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_
Visibility, | |
| 196 kVec2f_GrSLType, kDefault_GrSL
Precision, | |
| 197 "Xform", &xformUniName); | |
| 198 | |
| 199 fpb->codeAppend("vec4 diffuseColor = "); | |
| 200 fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers
[0], | |
| 201 args.fCoords[0].c_str(), | |
| 202 args.fCoords[0].getType()); | |
| 203 fpb->codeAppend(";"); | |
| 204 | |
| 205 fpb->codeAppend("vec4 normalColor = "); | |
| 206 fpb->appendTextureLookup(args.fSamplers[1], | |
| 207 args.fCoords[1].c_str(), | |
| 208 args.fCoords[1].getType()); | |
| 209 fpb->codeAppend(";"); | |
| 210 | |
| 211 fpb->codeAppend("vec3 normal = normalColor.rgb - vec3(0.5);"); | |
| 212 | |
| 213 fpb->codeAppendf("mat3 m = mat3(%s.x, -%s.y, 0.0, %s.y, %s.x, 0.0, 0
.0, 0.0, 1.0);", | |
| 214 xformUniName, xformUniName, xformUniName, xformUniN
ame); | |
| 215 | |
| 216 // TODO: inverse map the light direction vectors in the vertex shade
r rather than | |
| 217 // transforming all the normals here! | |
| 218 fpb->codeAppend("normal = normalize(m*normal);"); | |
| 219 | |
| 220 fpb->codeAppendf("float NdotL = clamp(dot(normal, %s), 0.0, 1.0);",
lightDirUniName); | |
| 221 // diffuse light | |
| 222 fpb->codeAppendf("vec3 result = %s*diffuseColor.rgb*NdotL;", lightCo
lorUniName); | |
| 223 // ambient light | |
| 224 fpb->codeAppendf("result += %s;", ambientColorUniName); | |
| 225 fpb->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOut
putColor); | |
| 226 } | |
| 227 | |
| 228 static void GenKey(const GrProcessor& proc, const GrGLSLCaps&, | |
| 229 GrProcessorKeyBuilder* b) { | |
| 230 // const LightingFP& lightingFP = proc.cast<LightingFP>(); | |
| 231 // only one shader generated currently | |
| 232 b->add32(0x0); | |
| 233 } | |
| 234 | |
| 235 protected: | |
| 236 void onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& p
roc) override { | |
| 237 const LightingFP& lightingFP = proc.cast<LightingFP>(); | |
| 238 | |
| 239 const SkVector3& lightDir = lightingFP.lightDir(); | |
| 240 if (lightDir != fLightDir) { | |
| 241 pdman.set3fv(fLightDirUni, 1, &lightDir.fX); | |
| 242 fLightDir = lightDir; | |
| 243 } | |
| 244 | |
| 245 const SkColor3f& lightColor = lightingFP.lightColor(); | |
| 246 if (lightColor != fLightColor) { | |
| 247 pdman.set3fv(fLightColorUni, 1, &lightColor.fX); | |
| 248 fLightColor = lightColor; | |
| 249 } | |
| 250 | |
| 251 const SkColor3f& ambientColor = lightingFP.ambientColor(); | |
| 252 if (ambientColor != fAmbientColor) { | |
| 253 pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX); | |
| 254 fAmbientColor = ambientColor; | |
| 255 } | |
| 256 | |
| 257 const SkVector& invNormRotation = lightingFP.invNormRotation(); | |
| 258 if (invNormRotation != fInvNormRotation) { | |
| 259 pdman.set2fv(fXformUni, 1, &invNormRotation.fX); | |
| 260 fInvNormRotation = invNormRotation; | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 private: | |
| 265 SkVector3 fLightDir; | |
| 266 GrGLProgramDataManager::UniformHandle fLightDirUni; | |
| 267 | |
| 268 SkColor3f fLightColor; | |
| 269 GrGLProgramDataManager::UniformHandle fLightColorUni; | |
| 270 | |
| 271 SkColor3f fAmbientColor; | |
| 272 GrGLProgramDataManager::UniformHandle fAmbientColorUni; | |
| 273 | |
| 274 SkVector fInvNormRotation; | |
| 275 GrGLProgramDataManager::UniformHandle fXformUni; | |
| 276 }; | |
| 277 | |
| 278 void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) c
onst override { | |
| 279 LightingGLFP::GenKey(*this, caps, b); | |
| 280 } | |
| 281 | |
| 282 const char* name() const override { return "LightingFP"; } | |
| 283 | |
| 284 void onComputeInvariantOutput(GrInvariantOutput* inout) const override { | |
| 285 inout->mulByUnknownFourComponents(); | |
| 286 } | |
| 287 | |
| 288 const SkVector3& lightDir() const { return fLightDir; } | |
| 289 const SkColor3f& lightColor() const { return fLightColor; } | |
| 290 const SkColor3f& ambientColor() const { return fAmbientColor; } | |
| 291 const SkVector& invNormRotation() const { return fInvNormRotation; } | |
| 292 | |
| 293 private: | |
| 294 GrGLFragmentProcessor* onCreateGLInstance() const override { return SkNEW(Li
ghtingGLFP); } | |
| 295 | |
| 296 bool onIsEqual(const GrFragmentProcessor& proc) const override { | |
| 297 const LightingFP& lightingFP = proc.cast<LightingFP>(); | |
| 298 return fDiffDeviceTransform == lightingFP.fDiffDeviceTransform && | |
| 299 fNormDeviceTransform == lightingFP.fNormDeviceTransform && | |
| 300 fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess && | |
| 301 fNormalTextureAccess == lightingFP.fNormalTextureAccess && | |
| 302 fLightDir == lightingFP.fLightDir && | |
| 303 fLightColor == lightingFP.fLightColor && | |
| 304 fAmbientColor == lightingFP.fAmbientColor && | |
| 305 fInvNormRotation == lightingFP.fInvNormRotation; | |
| 306 } | |
| 307 | |
| 308 GrCoordTransform fDiffDeviceTransform; | |
| 309 GrCoordTransform fNormDeviceTransform; | |
| 310 GrTextureAccess fDiffuseTextureAccess; | |
| 311 GrTextureAccess fNormalTextureAccess; | |
| 312 SkVector3 fLightDir; | |
| 313 SkColor3f fLightColor; | |
| 314 SkColor3f fAmbientColor; | |
| 315 | |
| 316 SkVector fInvNormRotation; | |
| 317 }; | |
| 318 | |
| 319 //////////////////////////////////////////////////////////////////////////// | |
| 320 | |
| 321 static bool make_mat(const SkBitmap& bm, | |
| 322 const SkMatrix& localMatrix1, | |
| 323 const SkMatrix* localMatrix2, | |
| 324 SkMatrix* result) { | |
| 325 | |
| 326 result->setIDiv(bm.width(), bm.height()); | |
| 327 | |
| 328 SkMatrix lmInverse; | |
| 329 if (!localMatrix1.invert(&lmInverse)) { | |
| 330 return false; | |
| 331 } | |
| 332 if (localMatrix2) { | |
| 333 SkMatrix inv; | |
| 334 if (!localMatrix2->invert(&inv)) { | |
| 335 return false; | |
| 336 } | |
| 337 lmInverse.postConcat(inv); | |
| 338 } | |
| 339 result->preConcat(lmInverse); | |
| 340 | |
| 341 return true; | |
| 342 } | |
| 343 | |
| 344 bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint
& paint, | |
| 345 const SkMatrix& viewM, const SkMa
trix* localMatrix, | |
| 346 GrColor* color, GrProcessorDataMa
nager* pdm, | |
| 347 GrFragmentProcessor** fp) const { | |
| 348 // we assume diffuse and normal maps have same width and height | |
| 349 // TODO: support different sizes | |
| 350 SkASSERT(fDiffuseMap.width() == fNormalMap.width() && | |
| 351 fDiffuseMap.height() == fNormalMap.height()); | |
| 352 SkMatrix diffM, normM; | |
| 353 | |
| 354 if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) { | |
| 355 return false; | |
| 356 } | |
| 357 | |
| 358 if (!make_mat(fNormalMap, fNormLocalMatrix, localMatrix, &normM)) { | |
| 359 return false; | |
| 360 } | |
| 361 | |
| 362 bool doBicubic; | |
| 363 GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode
( | |
| 364 SkTMin(paint.getFilterQuality(), kMedium
_SkFilterQuality), | |
| 365 viewM, | |
| 366 this->getLocalMatrix(), | |
| 367 &doBicubic); | |
| 368 SkASSERT(!doBicubic); | |
| 369 | |
| 370 GrTextureParams::FilterMode normFilterMode = GrSkFilterQualityToGrFilterMode
( | |
| 371 SkTMin(paint.getFilterQuality(), kMedium
_SkFilterQuality), | |
| 372 viewM, | |
| 373 fNormLocalMatrix, | |
| 374 &doBicubic); | |
| 375 SkASSERT(!doBicubic); | |
| 376 | |
| 377 // TODO: support other tile modes | |
| 378 GrTextureParams diffParams(kClamp_TileMode, diffFilterMode); | |
| 379 SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, | |
| 380 fDiffuseMap,
&diffParams)); | |
| 381 if (!diffuseTexture) { | |
| 382 SkErrorInternals::SetError(kInternalError_SkError, | |
| 383 "Couldn't convert bitmap to texture."); | |
| 384 return false; | |
| 385 } | |
| 386 | |
| 387 GrTextureParams normParams(kClamp_TileMode, normFilterMode); | |
| 388 SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, | |
| 389 fNormalMap, &
normParams)); | |
| 390 if (!normalTexture) { | |
| 391 SkErrorInternals::SetError(kInternalError_SkError, | |
| 392 "Couldn't convert bitmap to texture."); | |
| 393 return false; | |
| 394 } | |
| 395 | |
| 396 | |
| 397 *fp = SkNEW_ARGS(LightingFP, (pdm, diffuseTexture, normalTexture, | |
| 398 diffM, normM, diffParams, normParams, fLights, | |
| 399 fInvNormRotation)); | |
| 400 | |
| 401 *color = GrColorPackA4(paint.getAlpha()); | |
| 402 return true; | |
| 403 } | |
| 404 #else | |
| 405 | |
| 406 bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint
& paint, | |
| 407 const SkMatrix& viewM, const SkMa
trix* localMatrix, | |
| 408 GrColor* color, GrProcessorDataMa
nager*, | |
| 409 GrFragmentProcessor** fp) const { | |
| 410 SkDEBUGFAIL("Should not call in GPU-less build"); | |
| 411 return false; | |
| 412 } | |
| 413 | |
| 414 #endif | |
| 415 | |
| 416 //////////////////////////////////////////////////////////////////////////// | |
| 417 | |
| 418 bool SkLightingShaderImpl::isOpaque() const { | |
| 419 return fDiffuseMap.isOpaque(); | |
| 420 } | |
| 421 | |
| 422 size_t SkLightingShaderImpl::contextSize() const { | |
| 423 return 2 * sizeof(SkBitmapProcState) + sizeof(LightingShaderContext); | |
| 424 } | |
| 425 | |
| 426 SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(const SkLight
ingShaderImpl& shader, | |
| 427 const Context
Rec& rec, | |
| 428 SkBitmapProcS
tate* diffuseState, | |
| 429 SkBitmapProcS
tate* normalState) | |
| 430 : INHERITED(shader, rec) | |
| 431 , fDiffuseState(diffuseState) | |
| 432 , fNormalState(normalState) | |
| 433 { | |
| 434 const SkPixmap& pixmap = fDiffuseState->fPixmap; | |
| 435 bool isOpaque = pixmap.isOpaque(); | |
| 436 | |
| 437 // update fFlags | |
| 438 uint32_t flags = 0; | |
| 439 if (isOpaque && (255 == this->getPaintAlpha())) { | |
| 440 flags |= kOpaqueAlpha_Flag; | |
| 441 } | |
| 442 | |
| 443 fFlags = flags; | |
| 444 } | |
| 445 | |
| 446 SkLightingShaderImpl::LightingShaderContext::~LightingShaderContext() { | |
| 447 // The bitmap proc states have been created outside of the context on memory
that will be freed | |
| 448 // elsewhere. Call the destructors but leave the freeing of the memory to th
e caller. | |
| 449 fDiffuseState->~SkBitmapProcState(); | |
| 450 fNormalState->~SkBitmapProcState(); | |
| 451 } | |
| 452 | |
| 453 static inline SkPMColor convert(SkColor3f color, U8CPU a) { | |
| 454 if (color.fX <= 0.0f) { | |
| 455 color.fX = 0.0f; | |
| 456 } else if (color.fX >= 255.0f) { | |
| 457 color.fX = 255.0f; | |
| 458 } | |
| 459 | |
| 460 if (color.fY <= 0.0f) { | |
| 461 color.fY = 0.0f; | |
| 462 } else if (color.fY >= 255.0f) { | |
| 463 color.fY = 255.0f; | |
| 464 } | |
| 465 | |
| 466 if (color.fZ <= 0.0f) { | |
| 467 color.fZ = 0.0f; | |
| 468 } else if (color.fZ >= 255.0f) { | |
| 469 color.fZ = 255.0f; | |
| 470 } | |
| 471 | |
| 472 return SkPreMultiplyARGB(a, (int) color.fX, (int) color.fY, (int) color.fZ)
; | |
| 473 } | |
| 474 | |
| 475 // larger is better (fewer times we have to loop), but we shouldn't | |
| 476 // take up too much stack-space (each one here costs 16 bytes) | |
| 477 #define TMP_COUNT 16 | |
| 478 | |
| 479 void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y, | |
| 480 SkPMColor result[],
int count) { | |
| 481 const SkLightingShaderImpl& lightShader = static_cast<const SkLightingShader
Impl&>(fShader); | |
| 482 | |
| 483 uint32_t tmpColor[TMP_COUNT], tmpNormal[TMP_COUNT]; | |
| 484 SkPMColor tmpColor2[2*TMP_COUNT], tmpNormal2[2*TMP_COUNT]; | |
| 485 | |
| 486 SkBitmapProcState::MatrixProc diffMProc = fDiffuseState->getMatrixProc(); | |
| 487 SkBitmapProcState::SampleProc32 diffSProc = fDiffuseState->getSampleProc32()
; | |
| 488 | |
| 489 SkBitmapProcState::MatrixProc normalMProc = fNormalState->getMatrixProc(); | |
| 490 SkBitmapProcState::SampleProc32 normalSProc = fNormalState->getSampleProc32(
); | |
| 491 | |
| 492 int diffMax = fDiffuseState->maxCountForBufferSize(sizeof(tmpColor[0]) * TMP
_COUNT); | |
| 493 int normMax = fNormalState->maxCountForBufferSize(sizeof(tmpNormal[0]) * TMP
_COUNT); | |
| 494 int max = SkTMin(diffMax, normMax); | |
| 495 | |
| 496 SkASSERT(fDiffuseState->fPixmap.addr()); | |
| 497 SkASSERT(fNormalState->fPixmap.addr()); | |
| 498 | |
| 499 SkPoint3 norm, xformedNorm; | |
| 500 | |
| 501 do { | |
| 502 int n = count; | |
| 503 if (n > max) { | |
| 504 n = max; | |
| 505 } | |
| 506 | |
| 507 diffMProc(*fDiffuseState, tmpColor, n, x, y); | |
| 508 diffSProc(*fDiffuseState, tmpColor, n, tmpColor2); | |
| 509 | |
| 510 normalMProc(*fNormalState, tmpNormal, n, x, y); | |
| 511 normalSProc(*fNormalState, tmpNormal, n, tmpNormal2); | |
| 512 | |
| 513 for (int i = 0; i < n; ++i) { | |
| 514 SkASSERT(0xFF == SkColorGetA(tmpNormal2[i])); // opaque -> unpremul | |
| 515 norm.set(SkIntToScalar(SkGetPackedR32(tmpNormal2[i]))-127.0f, | |
| 516 SkIntToScalar(SkGetPackedG32(tmpNormal2[i]))-127.0f, | |
| 517 SkIntToScalar(SkGetPackedB32(tmpNormal2[i]))-127.0f); | |
| 518 norm.normalize(); | |
| 519 | |
| 520 xformedNorm.fX = lightShader.fInvNormRotation.fX * norm.fX + | |
| 521 lightShader.fInvNormRotation.fY * norm.fY; | |
| 522 xformedNorm.fY = lightShader.fInvNormRotation.fX * norm.fX - | |
| 523 lightShader.fInvNormRotation.fY * norm.fY; | |
| 524 xformedNorm.fZ = norm.fZ; | |
| 525 | |
| 526 SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]); | |
| 527 | |
| 528 SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f); | |
| 529 // This is all done in linear unpremul color space (each component 0
..255.0f though) | |
| 530 for (int l = 0; l < lightShader.fLights->numLights(); ++l) { | |
| 531 const SkLight& light = lightShader.fLights->light(l); | |
| 532 | |
| 533 if (SkLight::kAmbient_LightType == light.type()) { | |
| 534 accum += light.color().makeScale(255.0f); | |
| 535 } else { | |
| 536 SkScalar NdotL = xformedNorm.dot(light.dir()); | |
| 537 if (NdotL < 0.0f) { | |
| 538 NdotL = 0.0f; | |
| 539 } | |
| 540 | |
| 541 accum.fX += light.color().fX * SkColorGetR(diffColor) * Ndot
L; | |
| 542 accum.fY += light.color().fY * SkColorGetG(diffColor) * Ndot
L; | |
| 543 accum.fZ += light.color().fZ * SkColorGetB(diffColor) * Ndot
L; | |
| 544 } | |
| 545 } | |
| 546 | |
| 547 result[i] = convert(accum, SkColorGetA(diffColor)); | |
| 548 } | |
| 549 | |
| 550 result += n; | |
| 551 x += n; | |
| 552 count -= n; | |
| 553 } while (count > 0); | |
| 554 } | |
| 555 | |
| 556 //////////////////////////////////////////////////////////////////////////// | |
| 557 | |
| 558 #ifndef SK_IGNORE_TO_STRING | |
| 559 void SkLightingShaderImpl::toString(SkString* str) const { | |
| 560 str->appendf("LightingShader: ()"); | |
| 561 } | |
| 562 #endif | |
| 563 | |
| 564 SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) { | |
| 565 SkMatrix diffLocalM; | |
| 566 bool hasDiffLocalM = buf.readBool(); | |
| 567 if (hasDiffLocalM) { | |
| 568 buf.readMatrix(&diffLocalM); | |
| 569 } else { | |
| 570 diffLocalM.reset(); | |
| 571 } | |
| 572 | |
| 573 SkMatrix normLocalM; | |
| 574 bool hasNormLocalM = buf.readBool(); | |
| 575 if (hasNormLocalM) { | |
| 576 buf.readMatrix(&normLocalM); | |
| 577 } else { | |
| 578 normLocalM.reset(); | |
| 579 } | |
| 580 | |
| 581 SkBitmap diffuse; | |
| 582 if (!buf.readBitmap(&diffuse)) { | |
| 583 return NULL; | |
| 584 } | |
| 585 diffuse.setImmutable(); | |
| 586 | |
| 587 SkBitmap normal; | |
| 588 if (!buf.readBitmap(&normal)) { | |
| 589 return NULL; | |
| 590 } | |
| 591 normal.setImmutable(); | |
| 592 | |
| 593 int numLights = buf.readInt(); | |
| 594 | |
| 595 SkLightingShader::Lights::Builder builder; | |
| 596 | |
| 597 for (int l = 0; l < numLights; ++l) { | |
| 598 bool isAmbient = buf.readBool(); | |
| 599 | |
| 600 SkColor3f color; | |
| 601 if (!buf.readScalarArray(&color.fX, 3)) { | |
| 602 return NULL; | |
| 603 } | |
| 604 | |
| 605 if (isAmbient) { | |
| 606 builder.add(SkLight(color)); | |
| 607 } else { | |
| 608 SkVector3 dir; | |
| 609 if (!buf.readScalarArray(&dir.fX, 3)) { | |
| 610 return NULL; | |
| 611 } | |
| 612 builder.add(SkLight(color, dir)); | |
| 613 } | |
| 614 } | |
| 615 | |
| 616 SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish()); | |
| 617 | |
| 618 return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights, | |
| 619 SkVector::Make(1.0f, 0.0f), | |
| 620 &diffLocalM, &normLocalM)); | |
| 621 } | |
| 622 | |
| 623 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const { | |
| 624 this->INHERITED::flatten(buf); | |
| 625 | |
| 626 bool hasNormLocalM = !fNormLocalMatrix.isIdentity(); | |
| 627 buf.writeBool(hasNormLocalM); | |
| 628 if (hasNormLocalM) { | |
| 629 buf.writeMatrix(fNormLocalMatrix); | |
| 630 } | |
| 631 | |
| 632 buf.writeBitmap(fDiffuseMap); | |
| 633 buf.writeBitmap(fNormalMap); | |
| 634 | |
| 635 buf.writeInt(fLights->numLights()); | |
| 636 for (int l = 0; l < fLights->numLights(); ++l) { | |
| 637 const SkLight& light = fLights->light(l); | |
| 638 | |
| 639 bool isAmbient = SkLight::kAmbient_LightType == light.type(); | |
| 640 | |
| 641 buf.writeBool(isAmbient); | |
| 642 buf.writeScalarArray(&light.color().fX, 3); | |
| 643 if (!isAmbient) { | |
| 644 buf.writeScalarArray(&light.dir().fX, 3); | |
| 645 } | |
| 646 } | |
| 647 } | |
| 648 | |
| 649 bool SkLightingShaderImpl::computeNormTotalInverse(const ContextRec& rec, | |
| 650 SkMatrix* normTotalInverse) c
onst { | |
| 651 SkMatrix total; | |
| 652 total.setConcat(*rec.fMatrix, fNormLocalMatrix); | |
| 653 | |
| 654 const SkMatrix* m = &total; | |
| 655 if (rec.fLocalMatrix) { | |
| 656 total.setConcat(*m, *rec.fLocalMatrix); | |
| 657 m = &total; | |
| 658 } | |
| 659 return m->invert(normTotalInverse); | |
| 660 } | |
| 661 | |
| 662 SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec, | |
| 663 void* storage) const { | |
| 664 | |
| 665 SkMatrix diffTotalInv; | |
| 666 // computeTotalInverse was called in SkShader::createContext so we know it w
ill succeed | |
| 667 SkAssertResult(this->computeTotalInverse(rec, &diffTotalInv)); | |
| 668 | |
| 669 SkMatrix normTotalInv; | |
| 670 if (!this->computeNormTotalInverse(rec, &normTotalInv)) { | |
| 671 return NULL; | |
| 672 } | |
| 673 | |
| 674 void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext); | |
| 675 SkBitmapProcState* diffuseState = SkNEW_PLACEMENT(diffuseStateStorage, SkBit
mapProcState); | |
| 676 SkASSERT(diffuseState); | |
| 677 | |
| 678 diffuseState->fTileModeX = SkShader::kClamp_TileMode; | |
| 679 diffuseState->fTileModeY = SkShader::kClamp_TileMode; | |
| 680 diffuseState->fOrigBitmap = fDiffuseMap; | |
| 681 if (!diffuseState->chooseProcs(diffTotalInv, *rec.fPaint)) { | |
| 682 diffuseState->~SkBitmapProcState(); | |
| 683 return NULL; | |
| 684 } | |
| 685 | |
| 686 void* normalStateStorage = (char*)storage + sizeof(LightingShaderContext) +
sizeof(SkBitmapProcState); | |
| 687 SkBitmapProcState* normalState = SkNEW_PLACEMENT(normalStateStorage, SkBitma
pProcState); | |
| 688 SkASSERT(normalState); | |
| 689 | |
| 690 normalState->fTileModeX = SkShader::kClamp_TileMode; | |
| 691 normalState->fTileModeY = SkShader::kClamp_TileMode; | |
| 692 normalState->fOrigBitmap = fNormalMap; | |
| 693 if (!normalState->chooseProcs(normTotalInv, *rec.fPaint)) { | |
| 694 diffuseState->~SkBitmapProcState(); | |
| 695 normalState->~SkBitmapProcState(); | |
| 696 return NULL; | |
| 697 } | |
| 698 | |
| 699 return SkNEW_PLACEMENT_ARGS(storage, LightingShaderContext, (*this, rec, | |
| 700 diffuseState, n
ormalState)); | |
| 701 } | |
| 702 | |
| 703 /////////////////////////////////////////////////////////////////////////////// | |
| 704 | |
| 705 static bool bitmap_is_too_big(const SkBitmap& bm) { | |
| 706 // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it | |
| 707 // communicates between its matrix-proc and its sampler-proc. Until we can | |
| 708 // widen that, we have to reject bitmaps that are larger. | |
| 709 // | |
| 710 static const int kMaxSize = 65535; | |
| 711 | |
| 712 return bm.width() > kMaxSize || bm.height() > kMaxSize; | |
| 713 } | |
| 714 | |
| 715 SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& norm
al, | |
| 716 const Lights* lights, | |
| 717 const SkVector& invNormRotation, | |
| 718 const SkMatrix* diffLocalM, const SkMatrix* n
ormLocalM) { | |
| 719 if (diffuse.isNull() || bitmap_is_too_big(diffuse) || | |
| 720 normal.isNull() || bitmap_is_too_big(normal) || | |
| 721 diffuse.width() != normal.width() || | |
| 722 diffuse.height() != normal.height()) { | |
| 723 return nullptr; | |
| 724 } | |
| 725 | |
| 726 SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1)); | |
| 727 | |
| 728 return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights, | |
| 729 invNormRotation, diffLocalM, normLo
calM)); | |
| 730 } | |
| 731 | |
| 732 /////////////////////////////////////////////////////////////////////////////// | |
| 733 | |
| 734 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader) | |
| 735 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl) | |
| 736 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | |
| 737 | |
| 738 /////////////////////////////////////////////////////////////////////////////// | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1304673002:
Revert "Update SkLightingShader to support rotation" (Closed)
Base URL: https://skia.googlesource.com/skia.git@master