Moved ambient lights out of SkLight's light array

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 93 matching lines @@
 
 class ShadowFP : public GrFragmentProcessor {
 public:
     ShadowFP(sk_sp<GrFragmentProcessor> povDepth,
              sk_sp<GrFragmentProcessor> diffuse,
              sk_sp<SkLights> lights,
              int diffuseWidth, int diffuseHeight,
              const SkShadowParams& params,
              GrContext* context) {
 
-        // fuse all ambient lights into a single one
-        fAmbientColor.set(0.0f, 0.0f, 0.0f);
+        fAmbientColor = lights->ambientLightColor();
 

[robertphillips, 2016/08/26 17:31:28]

the old name was more descriptive of what is going on

[vjiaoblack, 2016/08/26 18:10:38]

Done.

-        fNumNonAmbLights = 0; // count of non-ambient lights
+        fNumLights = 0; // count of non-ambient lights
         for (int i = 0; i < lights->numLights(); ++i) {
-            if (SkLights::Light::kAmbient_LightType == lights->light(i).type()) {
-                fAmbientColor += lights->light(i).color();
-            } else if (fNumNonAmbLights < SkShadowShader::kMaxNonAmbientLights) {
-                fLightColor[fNumNonAmbLights] = lights->light(i).color();
-                if (lights->light(i).type() == SkLights::Light::kPoint_LightType) {
-                    fLightDirOrPos[fNumNonAmbLights] = lights->light(i).pos();
-                    fLightIntensity[fNumNonAmbLights] = lights->light(i).intensity();
-                } else {
-                    fLightDirOrPos[fNumNonAmbLights] = lights->light(i).dir();
-                    fLightIntensity[fNumNonAmbLights] = 0.0f;
-                }
-                fIsPointLight[fNumNonAmbLights] =
-                         SkLights::Light::kPoint_LightType == lights->light(i).type();
-
+            if (fNumLights < SkShadowShader::kMaxLights) {
+                fLightColor[fNumLights] = lights->light(i).color();

[robertphillips, 2016/08/26 17:31:29]

Won't this fail an assert ?

[vjiaoblack, 2016/08/26 18:10:38]

Done.

+                fLightDirOrPos[fNumLights] = lights->light(i).dir();
                 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,
+                fTexture[fNumLights] = sk_sp<GrTexture>(shadowMap->asTextureRef(context,
                                                            GrTextureParams::ClampNoFilter(),
                                                            SkSourceGammaTreatment::kIgnore));
-                fDepthMapAccess[fNumNonAmbLights].reset(fTexture[fNumNonAmbLights].get());
-                this->addTextureAccess(&fDepthMapAccess[fNumNonAmbLights]);
+                fDepthMapAccess[fNumLights].reset(fTexture[fNumLights].get());
+                this->addTextureAccess(&fDepthMapAccess[fNumLights]);
 
-                fDepthMapHeight[fNumNonAmbLights] = shadowMap->height();
-                fDepthMapWidth[fNumNonAmbLights] = shadowMap->width();
+                fDepthMapHeight[fNumLights] = shadowMap->height();
+                fDepthMapWidth[fNumLights] = shadowMap->width();
 
-                fNumNonAmbLights++;
+                fNumLights++;
             }
         }
 
         fWidth = diffuseWidth;
         fHeight = diffuseHeight;
 
         fShadowParams = params;
 
         this->registerChildProcessor(std::move(povDepth));
         this->registerChildProcessor(std::move(diffuse));
         this->initClassID<ShadowFP>();
     }
 
     class GLSLShadowFP : public GrGLSLFragmentProcessor {
     public:
         GLSLShadowFP() { }
 
         void emitCode(EmitArgs& args) override {
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
             const ShadowFP& shadowFP = args.fFp.cast<ShadowFP>();
 
-            SkASSERT(shadowFP.fNumNonAmbLights <= SkShadowShader::kMaxNonAmbientLights);
+            SkASSERT(shadowFP.fNumLights <= SkShadowShader::kMaxLights);
 
             // add uniforms
-            int32_t numLights = shadowFP.fNumNonAmbLights;
-            SkASSERT(numLights <= SkShadowShader::kMaxNonAmbientLights);
+            int32_t numLights = shadowFP.fNumLights;
+            SkASSERT(numLights <= SkShadowShader::kMaxLights);
 
             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* lightDirOrPosUniName[SkShadowShader::kMaxLights] = {nullptr};
+            const char* lightColorUniName[SkShadowShader::kMaxLights] = {nullptr};
+            const char* lightIntensityUniName[SkShadowShader::kMaxLights] = {nullptr};
 
-            const char* depthMapWidthUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
-            const char* depthMapHeightUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
+            const char* depthMapWidthUniName[SkShadowShader::kMaxLights] = {nullptr};
+            const char* depthMapHeightUniName[SkShadowShader::kMaxLights] = {nullptr};
 
-            for (int i = 0; i < shadowFP.fNumNonAmbLights; i++) {
+            for (int i = 0; i < shadowFP.fNumLights; 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");
@@ skipping 51 matching lines @@
                                                     kInt_GrSLType,
                                                     kDefault_GrSLPrecision,
                                                     "height", &heightUniName);
 
             SkString povDepth("povDepth");
             this->emitChild(0, nullptr, &povDepth, args);
 
             SkString diffuseColor("inDiffuseColor");
             this->emitChild(1, nullptr, &diffuseColor, args);
 
-            SkString depthMaps[SkShadowShader::kMaxNonAmbientLights];
+            SkString depthMaps[SkShadowShader::kMaxLights];
 
             // 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);",
                                      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++) {
+            for (int i = 0; i < shadowFP.fNumLights; 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");
@@ skipping 117 matching lines @@
 
             fragBuilder->codeAppendf("resultDiffuseColor *= vec4(%s, 1);",
                                      totalLightColor.c_str());
 
             fragBuilder->codeAppendf("%s = resultDiffuseColor;", args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const ShadowFP& shadowFP = proc.cast<ShadowFP>();
-            b->add32(shadowFP.fNumNonAmbLights);
+            b->add32(shadowFP.fNumLights);
             int isPL = 0;
-            for (int i = 0; i < SkShadowShader::kMaxNonAmbientLights; i++) {
+            for (int i = 0; i < SkShadowShader::kMaxLights; i++) {
                 isPL = isPL | ((shadowFP.fIsPointLight[i] ? 1 : 0) << i);
             }
             b->add32(isPL);
             b->add32(shadowFP.fShadowParams.fType);
         }
 
     protected:
         void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
             const ShadowFP &shadowFP = proc.cast<ShadowFP>();
 
@@ skipping 52 matching lines @@
             }
 
             const SkColor3f& ambientColor = shadowFP.ambientColor();
             if (ambientColor != fAmbientColor) {
                 pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
                 fAmbientColor = ambientColor;
             }
         }
 
     private:
-        SkVector3 fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
+        SkVector3 fLightDirOrPos[SkShadowShader::kMaxLights];
         GrGLSLProgramDataManager::UniformHandle
-                fLightDirOrPosUni[SkShadowShader::kMaxNonAmbientLights];
+                fLightDirOrPosUni[SkShadowShader::kMaxLights];
 
-        SkColor3f fLightColor[SkShadowShader::kMaxNonAmbientLights];
+        SkColor3f fLightColor[SkShadowShader::kMaxLights];
         GrGLSLProgramDataManager::UniformHandle
-                fLightColorUni[SkShadowShader::kMaxNonAmbientLights];
+                fLightColorUni[SkShadowShader::kMaxLights];
 
-        SkScalar fLightIntensity[SkShadowShader::kMaxNonAmbientLights];
+        SkScalar fLightIntensity[SkShadowShader::kMaxLights];
         GrGLSLProgramDataManager::UniformHandle
-                fLightIntensityUni[SkShadowShader::kMaxNonAmbientLights];
+                fLightIntensityUni[SkShadowShader::kMaxLights];
 
-        int fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
+        int fDepthMapWidth[SkShadowShader::kMaxLights];
         GrGLSLProgramDataManager::UniformHandle
-                fDepthMapWidthUni[SkShadowShader::kMaxNonAmbientLights];
+                fDepthMapWidthUni[SkShadowShader::kMaxLights];
 
-        int fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
+        int fDepthMapHeight[SkShadowShader::kMaxLights];
         GrGLSLProgramDataManager::UniformHandle
-                fDepthMapHeightUni[SkShadowShader::kMaxNonAmbientLights];
+                fDepthMapHeightUni[SkShadowShader::kMaxLights];
 
         int fWidth;
         GrGLSLProgramDataManager::UniformHandle fWidthUni;
         int fHeight;
         GrGLSLProgramDataManager::UniformHandle fHeightUni;
 
         SkScalar fBiasingConstant;
         GrGLSLProgramDataManager::UniformHandle fBiasingConstantUni;
         SkScalar fMinVariance;
         GrGLSLProgramDataManager::UniformHandle fMinVarianceUni;
 
         SkColor3f fAmbientColor;
         GrGLSLProgramDataManager::UniformHandle fAmbientColorUni;
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLShadowFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "shadowFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->mulByUnknownFourComponents();
     }
-    int32_t numLights() const { return fNumNonAmbLights; }
+    int32_t numLights() const { return fNumLights; }
     const SkColor3f& ambientColor() const { return fAmbientColor; }
     bool isPointLight(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fIsPointLight[i];
     }
     const SkVector3& lightDirOrPos(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fLightDirOrPos[i];
     }
     const SkVector3& lightColor(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fLightColor[i];
     }
     SkScalar lightIntensity(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fLightIntensity[i];
     }
 
     int depthMapWidth(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fDepthMapWidth[i];
     }
     int depthMapHeight(int i) const {
-        SkASSERT(i < fNumNonAmbLights);
+        SkASSERT(i < fNumLights);
         return fDepthMapHeight[i];
     }
     int width() const {return fWidth; }
     int height() const {return fHeight; }
 
     const SkShadowParams& shadowParams() const {return fShadowParams; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLShadowFP; }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const ShadowFP& shadowFP = proc.cast<ShadowFP>();
         if (fAmbientColor != shadowFP.fAmbientColor ||
-            fNumNonAmbLights != shadowFP.fNumNonAmbLights) {
+            fNumLights != shadowFP.fNumLights) {
             return false;
         }
 
         if (fWidth != shadowFP.fWidth || fHeight != shadowFP.fHeight) {
             return false;
         }
 
-        for (int i = 0; i < fNumNonAmbLights; i++) {
+        for (int i = 0; i < fNumLights; i++) {
             if (fLightDirOrPos[i] != shadowFP.fLightDirOrPos[i] ||
                 fLightColor[i] != shadowFP.fLightColor[i] ||
                 fLightIntensity[i] != shadowFP.fLightIntensity[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;
+    int              fNumLights;
 
-    bool             fIsPointLight[SkShadowShader::kMaxNonAmbientLights];
-    SkVector3        fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
-    SkColor3f        fLightColor[SkShadowShader::kMaxNonAmbientLights];
-    SkScalar         fLightIntensity[SkShadowShader::kMaxNonAmbientLights];
-    GrTextureAccess  fDepthMapAccess[SkShadowShader::kMaxNonAmbientLights];
-    sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
+    bool             fIsPointLight[SkShadowShader::kMaxLights];
+    SkVector3        fLightDirOrPos[SkShadowShader::kMaxLights];
+    SkColor3f        fLightColor[SkShadowShader::kMaxLights];
+    SkScalar         fLightIntensity[SkShadowShader::kMaxLights];
+    GrTextureAccess  fDepthMapAccess[SkShadowShader::kMaxLights];
+    sk_sp<GrTexture> fTexture[SkShadowShader::kMaxLights];
 
-    int              fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
-    int              fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
+    int              fDepthMapWidth[SkShadowShader::kMaxLights];
+    int              fDepthMapHeight[SkShadowShader::kMaxLights];
 
     int              fHeight;
     int              fWidth;
 
     SkShadowParams   fShadowParams;
 
     SkColor3f        fAmbientColor;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ skipping 83 matching lines @@
 
     do {
         int n = SkTMin(count, BUFFER_MAX);
 
         fPovDepthContext->shadeSpan(x, y, diffuse, n);
         fDiffuseContext->shadeSpan(x, y, diffuse, n);
 
         for (int i = 0; i < n; ++i) {
 
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[i]);
 

[robertphillips, 2016/08/26 17:31:29]

Again, where does the ambient contribution get added ?

[vjiaoblack, 2016/08/26 18:10:38]

right at the beginning?

             SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
             // This is all done in linear unpremul color space (each component 0..255.0f though)
+
+            accum.fX += lightShader.fLights->ambientLightColor().fX * SkColorGetR(diffColor);
+            accum.fY += lightShader.fLights->ambientLightColor().fY * SkColorGetG(diffColor);
+            accum.fZ += lightShader.fLights->ambientLightColor().fZ * SkColorGetB(diffColor);
+
             for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
                 const SkLights::Light& light = lightShader.fLights->light(l);
 
-                if (SkLights::Light::kAmbient_LightType == light.type()) {
-                    accum.fX += light.color().fX * SkColorGetR(diffColor);
-                    accum.fY += light.color().fY * SkColorGetG(diffColor);
-                    accum.fZ += light.color().fZ * SkColorGetB(diffColor);
-                } else if (SkLights::Light::kDirectional_LightType == light.type()) {
-                    // scaling by fZ accounts for lighting direction
-                    accum.fX += light.color().makeScale(light.dir().fZ).fX *
-                                                        SkColorGetR(diffColor);
-                    accum.fY += light.color().makeScale(light.dir().fZ).fY *
-                                                        SkColorGetG(diffColor);
-                    accum.fZ += light.color().makeScale(light.dir().fZ).fZ *
-                                                        SkColorGetB(diffColor);
-                } else {
-                    // TODO: do point lights for raster, currently treated like ambient
-                    accum.fX += light.color().fX * SkColorGetR(diffColor);
-                    accum.fY += light.color().fY * SkColorGetG(diffColor);
-                    accum.fZ += light.color().fZ * SkColorGetB(diffColor);
-                }
+                // scaling by fZ accounts for lighting direction
+                accum.fX += light.color().makeScale(light.dir().fZ).fX * SkColorGetR(diffColor);
+                accum.fY += light.color().makeScale(light.dir().fZ).fY * SkColorGetG(diffColor);
+                accum.fZ += light.color().makeScale(light.dir().fZ).fZ * SkColorGetB(diffColor);
             }
 
             result[i] = convert(accum, SkColorGetA(diffColor));
         }
 
         result += n;
         x += n;
         count -= n;
     } while (count > 0);
 }
@@ skipping 105 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif