Optimizations and more documentation of SkShadowShader

src/core/SkShadowShader.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkReadBuffer.h"
 #include "SkShadowShader.h"
@@ skipping 100 matching lines @@
              const SkShadowParams& params,
              GrContext* context) {
 
         fAmbientColor = lights->ambientLightColor();
 
         fNumNonAmbLights = 0; // count of non-ambient lights
         for (int i = 0; i < lights->numLights(); ++i) {
             if (fNumNonAmbLights < SkShadowShader::kMaxNonAmbientLights) {
                 fLightColor[fNumNonAmbLights] = lights->light(i).color();
 
-                if (SkLights::Light::kDirectional_LightType == lights->light(i).type()) {
+                if (SkLights::Light::kPoint_LightType == lights->light(i).type()) {
+                    fLightDirOrPos[fNumNonAmbLights] = lights->light(i).pos();
+                    fInvSqLightIntensity[fNumNonAmbLights] = 1.0f /

[jvanverth1, 2016/08/29 18:30:14]

The standard formula for a point light is L = I * clamp(N*L, 0, 1) /
attenuation, where I is the light's radiant intensity and L is outgoing
radiance. Physically, I has no upper bound per component, but we're using color,
which usually does have an upper bound of one. So either you can approximate the
full range by saying that I = lightIntensity*lightColor, where lightIntensity is
a single value that scales the color, or you can let the color mean radiant
intensity and allow values greater than one. Since we're using a uniform for
color I'd recommend the latter. Multiplying by 1.0/lightIntensity^2 makes no
sense to me physically.

[vjiaoblack, 2016/08/29 19:45:21]

Okay, i'll simplify the model!

Done.

+                            (lights->light(i).intensity() * lights->light(i).intensity());
+                } else {
                     fLightDirOrPos[fNumNonAmbLights] = lights->light(i).dir();
-                    fLightIntensity[fNumNonAmbLights] = 0.0f;
-                } else if (SkLights::Light::kPoint_LightType == lights->light(i).type()) {
-                    fLightDirOrPos[fNumNonAmbLights] = lights->light(i).pos();
-                    fLightIntensity[fNumNonAmbLights] = lights->light(i).intensity();
+                    fInvSqLightIntensity[fNumNonAmbLights] = 0.0f;
                 }
 
                 fIsPointLight[fNumNonAmbLights] =
                         SkLights::Light::kPoint_LightType == lights->light(i).type();
 
                 SkImage_Base* shadowMap = ((SkImage_Base*)lights->light(i).getShadowMap());
 
                 // gets deleted when the ShadowFP is destroyed, and frees the GrTexture*
                 fTexture[fNumNonAmbLights] = sk_sp<GrTexture>(shadowMap->asTextureRef(context,
                                                            GrTextureParams::ClampNoFilter(),
@@ skipping 30 matching lines @@
             SkASSERT(shadowFP.fNumNonAmbLights <= SkShadowShader::kMaxNonAmbientLights);
 
             // add uniforms
             int32_t numLights = shadowFP.fNumNonAmbLights;
             SkASSERT(numLights <= SkShadowShader::kMaxNonAmbientLights);
 
             int blurAlgorithm = shadowFP.fShadowParams.fType;
 
             const char* lightDirOrPosUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
             const char* lightColorUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
-            const char* lightIntensityUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
+            const char* invLightIntensitySqUniName[SkShadowShader::kMaxNonAmbientLights] =
+                    {nullptr};
+
+            const char* ambientColorUniName = nullptr;
 
             const char* depthMapWidthUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
             const char* depthMapHeightUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
+            const char* widthUniName = nullptr; // dimensions of povDepth
+            const char* heightUniName = nullptr;
 
+            const char* shBiasUniName = nullptr;
+            const char* minVarianceUniName = nullptr;
+
+            // setting uniforms
             for (int i = 0; i < shadowFP.fNumNonAmbLights; i++) {
                 SkString lightDirOrPosUniNameStr("lightDir");
                 lightDirOrPosUniNameStr.appendf("%d", i);
                 SkString lightColorUniNameStr("lightColor");
                 lightColorUniNameStr.appendf("%d", i);
                 SkString lightIntensityUniNameStr("lightIntensity");
                 lightIntensityUniNameStr.appendf("%d", i);
 
                 SkString depthMapWidthUniNameStr("dmapWidth");
                 depthMapWidthUniNameStr.appendf("%d", i);
                 SkString depthMapHeightUniNameStr("dmapHeight");
                 depthMapHeightUniNameStr.appendf("%d", i);
 
                 fLightDirOrPosUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                              kVec3f_GrSLType,
                                                              kDefault_GrSLPrecision,
                                                              lightDirOrPosUniNameStr.c_str(),
                                                              &lightDirOrPosUniName[i]);
                 fLightColorUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                                kVec3f_GrSLType,
                                                                kDefault_GrSLPrecision,
                                                                lightColorUniNameStr.c_str(),
                                                                &lightColorUniName[i]);
-                fLightIntensityUni[i] =
+                fInvSqLightIntensityUni[i] =
                         uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kFloat_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    lightIntensityUniNameStr.c_str(),
-                                                   &lightIntensityUniName[i]);
+                                                   &invLightIntensitySqUniName[i]);
 
                 fDepthMapWidthUni[i]  = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kInt_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    depthMapWidthUniNameStr.c_str(),
                                                    &depthMapWidthUniName[i]);
                 fDepthMapHeightUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kInt_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    depthMapHeightUniNameStr.c_str(),
                                                    &depthMapHeightUniName[i]);
             }
 
-            const char* shBiasUniName = nullptr;
-            const char* minVarianceUniName = nullptr;
-
             fBiasingConstantUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                              kFloat_GrSLType,
                                                              kDefault_GrSLPrecision,
                                                              "shadowBias", &shBiasUniName);
             fMinVarianceUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                          kFloat_GrSLType,
                                                          kDefault_GrSLPrecision,
                                                          "minVariance", &minVarianceUniName);
 
-            const char* widthUniName = nullptr;
-            const char* heightUniName = nullptr;
-
             fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kInt_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    "width", &widthUniName);
             fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                     kInt_GrSLType,
                                                     kDefault_GrSLPrecision,
                                                     "height", &heightUniName);
 
+            fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                          kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                                          "AmbientColor", &ambientColorUniName);
+
+            SkString povDepthSampler("_povDepth");
             SkString povDepth("povDepth");
-            this->emitChild(0, nullptr, &povDepth, args);
+            this->emitChild(0, nullptr, &povDepthSampler, args);
+            fragBuilder->codeAppendf("vec4 %s = %s;", povDepth.c_str(), povDepthSampler.c_str());
 
+            SkString diffuseColorSampler("_inDiffuseColor");
             SkString diffuseColor("inDiffuseColor");
-            this->emitChild(1, nullptr, &diffuseColor, args);
+            this->emitChild(1, nullptr, &diffuseColorSampler, args);
+            fragBuilder->codeAppendf("vec4 %s = %s;", diffuseColor.c_str(),
+                                     diffuseColorSampler.c_str());
 
             SkString depthMaps[SkShadowShader::kMaxNonAmbientLights];
 
+            fragBuilder->codeAppendf("vec4 resultDiffuseColor = %s;", diffuseColor.c_str());
+            fragBuilder->codeAppendf("vec3 totalLightColor = vec3(0,0,0);");

[jvanverth1, 2016/08/29 18:30:14]

You can just do vec3(0);
Don't need appendf.

[vjiaoblack, 2016/08/29 19:45:21]

Done.

+
+            // probability that a fragment is lit. For each light, we multiply this by the
+            // light's color to get its contribution to totalLightColor.
+            fragBuilder->codeAppendf("float lightProbability;");
+
+            // coordinates of current fragment in world space
+            fragBuilder->codeAppendf("vec3 worldCor;");

[jvanverth1, 2016/08/29 18:30:14]

Don't need appendf here, can use append. Same for line above.

[vjiaoblack, 2016/08/29 19:45:22]

Done.

+
             // Multiply by 255 to transform from sampler coordinates to world
             // coordinates (since 1 channel is 0xFF)
-            fragBuilder->codeAppendf("vec3 worldCor = vec3(vMatrixCoord_0_1_Stage0 * "
-                                                     "vec2(%s, %s), %s.b * 255);",
+            fragBuilder->codeAppendf("worldCor = vec3(vMatrixCoord_0_1_Stage0 * "
+                                                "vec2(%s, %s), %s.b * 255);",
                                      widthUniName, heightUniName, povDepth.c_str());
 
             // Applies the offset indexing that goes from our view space into the light's space.
             for (int i = 0; i < shadowFP.fNumNonAmbLights; i++) {
                 SkString povCoord("povCoord");
                 povCoord.appendf("%d", i);
 
                 // vMatrixCoord_0_1_Stage0 is the texture sampler coordinates.
                 // povDepth.b * 255 scales it to 0 - 255, bringing it to world space,
                 // and the / vec2(width, height) brings it back to a sampler coordinate
                 SkString offset("offset");
                 offset.appendf("%d", i);
 
                 SkString scaleVec("scaleVec");
                 scaleVec.appendf("%d", i);
 
-                SkString scaleOffsetVec("scaleOffsetVec");
-                scaleOffsetVec.appendf("%d", i);
-
                 fragBuilder->codeAppendf("vec2 %s;", offset.c_str());
 
                 if (shadowFP.fIsPointLight[i]) {
                     fragBuilder->codeAppendf("vec3 fragToLight%d = %s - worldCor;",
                                              i, lightDirOrPosUniName[i]);
                     fragBuilder->codeAppendf("float distsq%d = dot(fragToLight%d, fragToLight%d);"
                                              "fragToLight%d = normalize(fragToLight%d);",
                                              i, i, i, i, i);
-                    fragBuilder->codeAppendf("%s = -vec2(%s.x - worldCor.x, worldCor.y - %s.y)*"
-                                                    "(povDepth.b) / vec2(%s, %s);",
-                                             offset.c_str(), lightDirOrPosUniName[i],
-                                             lightDirOrPosUniName[i],
-                                             widthUniName, heightUniName);
+                    fragBuilder->codeAppendf("%s = vec2(worldCor - %s) * povDepth.b;",
+                                             offset.c_str(), lightDirOrPosUniName[i]);
                 } else {
-                    fragBuilder->codeAppendf("%s = vec2(%s) * povDepth.b * 255 / vec2(%s, %s);",
-                                             offset.c_str(), lightDirOrPosUniName[i],
-                                             widthUniName, heightUniName);
+                    fragBuilder->codeAppendf("%s = vec2(%s) * povDepth.b * 255 * "
+                                                  "vec2(1.0, -1.0);",

[jvanverth1, 2016/08/29 18:30:14]

Replace 255*vec2(1, -1) with vec2(255, -255)? And is this the right order?
Should it be -255, 255? Either way, a comment would be helpful as it's a little
unclear what's going on here.

[vjiaoblack, 2016/08/29 19:45:22]

Done.

+                                             offset.c_str(), lightDirOrPosUniName[i]);
                 }
-                fragBuilder->codeAppendf("vec2 %s = (vec2(%s, %s) / vec2(%s, %s));",
-                                         scaleVec.c_str(),
+                fragBuilder->codeAppendf("vec2 %s = (vec2(%s, %s) *"
+                                                    "vMatrixCoord_0_1_Stage0 +"
+                                                    "vec2(0,%s - %s) + "
+                                                    "%s) / vec2(%s, %s);",
+                                         povCoord.c_str(),
                                          widthUniName, heightUniName,
+                                         depthMapHeightUniName[i], heightUniName,
+                                         offset.c_str(),
                                          depthMapWidthUniName[i], depthMapHeightUniName[i]);
 
-                fragBuilder->codeAppendf("vec2 %s = 1 - %s;\n",
-                                         scaleOffsetVec.c_str(),
-                                         scaleVec.c_str());
-
-                fragBuilder->codeAppendf("vec2 %s = (vMatrixCoord_0_1_Stage0 + "
-                                                   "vec2(%s.x, 0 - %s.y)) "
-                                                   " * %s + vec2(0,1) * %s;",
-                                         povCoord.c_str(), offset.c_str(), offset.c_str(),
-                                         scaleVec.c_str(), scaleOffsetVec.c_str());
-
                 fragBuilder->appendTextureLookup(&depthMaps[i], args.fTexSamplers[i],
                                                  povCoord.c_str(),
                                                  kVec2f_GrSLType);
 
             }
 
-            const char* ambientColorUniName = nullptr;
-            fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                          kVec3f_GrSLType, kDefault_GrSLPrecision,
-                                                          "AmbientColor", &ambientColorUniName);
+            // helper variables for calculating shadowing
 
-            fragBuilder->codeAppendf("vec4 resultDiffuseColor = %s;", diffuseColor.c_str());
+            // variance of depth at this fragment in the context of surrounding area
+            // (area size and weighting dependent on blur size and type)
+            fragBuilder->codeAppendf("float variance;");
 
-            SkString totalLightColor("totalLightColor");
-            fragBuilder->codeAppendf("vec3 %s = vec3(0,0,0);", totalLightColor.c_str());
-
-            fragBuilder->codeAppendf("float lightProbability;");
-            fragBuilder->codeAppendf("float variance;");
+            // the difference in depth between the user POV and light POV.
             fragBuilder->codeAppendf("float d;");
 
+            // add up light contributions from all lights to totalLightColor
             for (int i = 0; i < numLights; i++) {
                 if (!shadowFP.isPointLight(i)) {
                     fragBuilder->codeAppendf("lightProbability = 1;");
 
-                    // 1/512 is less than half a pixel; imperceptible
-                    fragBuilder->codeAppendf("if (%s.b <= %s.b + 1/512) {",
+                    // 1/512 == .00195... is less than half a pixel; imperceptible
+                    fragBuilder->codeAppendf("if (%s.b <= %s.b + .001953125) {",

[jvanverth1, 2016/08/29 18:30:14]

Good catch.

[vjiaoblack, 2016/08/29 19:45:22]

Done.

                                              povDepth.c_str(), depthMaps[i].c_str());
                     if (blurAlgorithm == SkShadowParams::kVariance_ShadowType) {
-                        fragBuilder->codeAppendf("vec2 moments%d = vec2(%s.b * 255,"
-                                                                       "%s.g * 255 * 256 );",
+                        // we stored depth^2 in the SPFCanvas after dividing it by 256,
+                        // so here we multiply it by 256.

[jvanverth1, 2016/08/29 18:30:14]

Where are we multiplying by 256?

[vjiaoblack, 2016/08/29 19:45:21]

Acknowledged.

+                        fragBuilder->codeAppendf("vec2 moments%d = vec2(%s.b, %s.g);",
                                                  i, depthMaps[i].c_str(), depthMaps[i].c_str());
 
                         // variance biasing lessens light bleeding
                         fragBuilder->codeAppendf("variance = max(moments%d.y - "
                                                                 "(moments%d.x * moments%d.x),"
                                                                 "%s);", i, i, i,
                                                  minVarianceUniName);
 
-                        fragBuilder->codeAppendf("d = (%s.b * 255) - moments%d.x;",
+                        fragBuilder->codeAppendf("d = (%s.b) - moments%d.x;",
                                                  povDepth.c_str(), i);
                         fragBuilder->codeAppendf("lightProbability = "
                                                          "(variance / (variance + d * d));");
 
                         SkString clamp("clamp");
                         clamp.appendf("%d", i);
 
                         // choosing between light artifacts or correct shape shadows
                         // linstep
                         fragBuilder->codeAppendf("float %s = clamp((lightProbability - %s) /"
-                                                         "(1 - %s), 0, 1);",
+                                                            "(1 - %s), 0, 1);",

[jvanverth1, 2016/08/29 18:30:14]

Nit: Indent to parenthesis.

[vjiaoblack, 2016/08/29 19:45:22]

Done.

                                                  clamp.c_str(), shBiasUniName, shBiasUniName);
 
                         fragBuilder->codeAppendf("lightProbability = %s;", clamp.c_str());
                     } else {
                         fragBuilder->codeAppendf("if (%s.b >= %s.b) {",
                                                  povDepth.c_str(), depthMaps[i].c_str());
                         fragBuilder->codeAppendf("lightProbability = 1;");
                         fragBuilder->codeAppendf("} else { lightProbability = 0; }");
                     }
 
                     // VSM: The curved shadows near plane edges are artifacts from blurring
                     fragBuilder->codeAppendf("}");
-                    fragBuilder->codeAppendf("%s += dot(vec3(0,0,1), %s) * %s * "
-                                                   "lightProbability;",
-                                             totalLightColor.c_str(),
+                    fragBuilder->codeAppendf("totalLightColor += %s.z * %s * "
+                                                                "lightProbability;",
                                              lightDirOrPosUniName[i],
                                              lightColorUniName[i]);
                 } else {
                     // fragToLight%d.z is equal to the fragToLight dot the surface normal.
-                    fragBuilder->codeAppendf("%s += max(fragToLight%d.z, 0) * %s /"
-                                                   "(1 + distsq%d / (%s * %s));",
-                                             totalLightColor.c_str(), i,
-                                             lightColorUniName[i], i,
-                                             lightIntensityUniName[i],
-                                             lightIntensityUniName[i]);
+                    fragBuilder->codeAppendf("totalLightColor += max(fragToLight%d.z, 0) * %s /"
+                                                                "(1 + distsq%d * %s);",
+                                             i, lightColorUniName[i], i,
+                                             invLightIntensitySqUniName[i]);
                 }
             }
 
-            fragBuilder->codeAppendf("%s += %s;", totalLightColor.c_str(), ambientColorUniName);
-
-            fragBuilder->codeAppendf("resultDiffuseColor *= vec4(%s, 1);",
-                                     totalLightColor.c_str());
-
-            fragBuilder->codeAppendf("%s = resultDiffuseColor;", args.fOutputColor);
+            fragBuilder->codeAppendf("totalLightColor += %s;", ambientColorUniName);
+            fragBuilder->codeAppendf("%s = resultDiffuseColor * vec4(totalLightColor, 1);",
+                                     args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const ShadowFP& shadowFP = proc.cast<ShadowFP>();
             b->add32(shadowFP.fNumNonAmbLights);
             int isPL = 0;
             for (int i = 0; i < SkShadowShader::kMaxNonAmbientLights; i++) {
                 isPL = isPL | ((shadowFP.fIsPointLight[i] ? 1 : 0) << i);
             }
@@ skipping 12 matching lines @@
                     fLightDirOrPos[i] = lightDirOrPos;
                 }
 
                 const SkColor3f& lightColor = shadowFP.lightColor(i);
                 if (lightColor != fLightColor[i]) {
                     pdman.set3fv(fLightColorUni[i], 1, &lightColor.fX);
                     fLightColor[i] = lightColor;
                 }
 
                 SkScalar lightIntensity = shadowFP.lightIntensity(i);
-                if (lightIntensity != fLightIntensity[i]) {
-                    pdman.set1f(fLightIntensityUni[i], lightIntensity);
-                    fLightIntensity[i] = lightIntensity;
+                if (lightIntensity != fInvSqLightIntensity[i]) {
+                    pdman.set1f(fInvSqLightIntensityUni[i], lightIntensity);
+                    fInvSqLightIntensity[i] = lightIntensity;
                 }
 
                 int depthMapWidth = shadowFP.depthMapWidth(i);
                 if (depthMapWidth != fDepthMapWidth[i]) {
                     pdman.set1i(fDepthMapWidthUni[i], depthMapWidth);
                     fDepthMapWidth[i] = depthMapWidth;
                 }
                 int depthMapHeight = shadowFP.depthMapHeight(i);
                 if (depthMapHeight != fDepthMapHeight[i]) {
                     pdman.set1i(fDepthMapHeightUni[i], depthMapHeight);
@@ skipping 33 matching lines @@
 
     private:
         SkVector3 fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
                 fLightDirOrPosUni[SkShadowShader::kMaxNonAmbientLights];
 
         SkColor3f fLightColor[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
                 fLightColorUni[SkShadowShader::kMaxNonAmbientLights];
 
-        SkScalar fLightIntensity[SkShadowShader::kMaxNonAmbientLights];
+        SkScalar fInvSqLightIntensity[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
-                fLightIntensityUni[SkShadowShader::kMaxNonAmbientLights];
+                fInvSqLightIntensityUni[SkShadowShader::kMaxNonAmbientLights];
 
         int fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
                 fDepthMapWidthUni[SkShadowShader::kMaxNonAmbientLights];
 
         int fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
                 fDepthMapHeightUni[SkShadowShader::kMaxNonAmbientLights];
 
         int fWidth;
@@ skipping 28 matching lines @@
     const SkVector3& lightDirOrPos(int i) const {
         SkASSERT(i < fNumNonAmbLights);
         return fLightDirOrPos[i];
     }
     const SkVector3& lightColor(int i) const {
         SkASSERT(i < fNumNonAmbLights);
         return fLightColor[i];
     }
     SkScalar lightIntensity(int i) const {
         SkASSERT(i < fNumNonAmbLights);
-        return fLightIntensity[i];
+        return fInvSqLightIntensity[i];
     }
 
     int depthMapWidth(int i) const {
         SkASSERT(i < fNumNonAmbLights);
         return fDepthMapWidth[i];
     }
     int depthMapHeight(int i) const {
         SkASSERT(i < fNumNonAmbLights);
         return fDepthMapHeight[i];
     }
@@ skipping 12 matching lines @@
             return false;
         }
 
         if (fWidth != shadowFP.fWidth || fHeight != shadowFP.fHeight) {
             return false;
         }
 
         for (int i = 0; i < fNumNonAmbLights; i++) {
             if (fLightDirOrPos[i] != shadowFP.fLightDirOrPos[i] ||
                 fLightColor[i] != shadowFP.fLightColor[i] ||
-                fLightIntensity[i] != shadowFP.fLightIntensity[i] ||
+                fInvSqLightIntensity[i] != shadowFP.fInvSqLightIntensity[i] ||
                 fIsPointLight[i] != shadowFP.fIsPointLight[i]) {
                 return false;
             }
 
             if (fDepthMapWidth[i] != shadowFP.fDepthMapWidth[i] ||
                 fDepthMapHeight[i] != shadowFP.fDepthMapHeight[i]) {
                 return false;
             }
         }
 
         return true;
     }
 
     int              fNumNonAmbLights;
 
     bool             fIsPointLight[SkShadowShader::kMaxNonAmbientLights];
     SkVector3        fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
     SkColor3f        fLightColor[SkShadowShader::kMaxNonAmbientLights];
-    SkScalar         fLightIntensity[SkShadowShader::kMaxNonAmbientLights];
+    SkScalar         fInvSqLightIntensity[SkShadowShader::kMaxNonAmbientLights];
     GrTextureAccess  fDepthMapAccess[SkShadowShader::kMaxNonAmbientLights];
     sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
 
     int              fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
     int              fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
 
     int              fHeight;
     int              fWidth;
 
     SkShadowParams   fShadowParams;
@@ skipping 238 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif