raster shadows

src/core/SkShadowShader.cpp

Index: src/core/SkShadowShader.cpp
diff --git a/src/core/SkShadowShader.cpp b/src/core/SkShadowShader.cpp
index 5fc992acc14dd790ab86e43e6a761ecc7b7db8bc..900da7912320553402e41dafa58e924e8d08c523 100644
--- a/src/core/SkShadowShader.cpp
+++ b/src/core/SkShadowShader.cpp
@@ -541,41 +541,95 @@ void SkShadowShaderImpl::ShadowShaderContext::shadeSpan(int x, int y,
     const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
 
     SkPMColor diffuse[BUFFER_MAX];
+    SkPMColor povDepth[BUFFER_MAX];
+

[robertphillips, 2016/08/18 17:33:16]

Let's (you, me, Jim & maybe Mike) talk about changing the SkLights contract so
it will compress the ambient lights for you.

[vjiaoblack, 2016/08/24 14:34:06]

Acknowledged.

+    SkPixmap* shPixels[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
+    int nonAmbLightCnt = 0;
+    for (int i = 0; i < lightShader.fLights->numLights(); i++) {
+        if (lightShader.fLights->light(i).type() == SkLights::Light::kDirectional_LightType) {

[robertphillips, 2016/08/18 17:33:16]

Eeek! A new&delete for each span, for each shadowed light!

[vjiaoblack, 2016/08/24 14:34:06]

Done.

+            shPixels[nonAmbLightCnt] = new SkPixmap();
+            if (!lightShader.fLights->light(i).getShadowMap()->
+                        peekPixels(shPixels[nonAmbLightCnt])) {
+                shPixels[nonAmbLightCnt] = nullptr;
+            }
+            nonAmbLightCnt++;
+        }
+    }
 
     do {
         int n = SkTMin(count, BUFFER_MAX);
 
-        fPovDepthContext->shadeSpan(x, y, diffuse, n);
         fDiffuseContext->shadeSpan(x, y, diffuse, n);
+        fPovDepthContext->shadeSpan(x, y, povDepth, n);
 
         for (int i = 0; i < n; ++i) {
-
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[i]);

[robertphillips, 2016/08/18 17:33:16]

It seems like the depth map won't be in premul space

[vjiaoblack, 2016/08/24 14:34:06]

Done.

+            SkColor povDepthColor = SkUnPreMultiply::PMColorToColor(povDepth[i]);
 
-            SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
+            SkColor3f totalColor = SkColor3f::Make(0.0f, 0.0f, 0.0f);
+            SkColor3f totalLight = SkColor3f::Make(0.0f, 0.0f, 0.0f);
             // This is all done in linear unpremul color space (each component 0..255.0f though)
+
+            nonAmbLightCnt = 0;
             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 {
-                    // 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);
+                if (light.type() == SkLights::Light::kDirectional_LightType) {
+                    int xOffset = SkScalarRoundToInt(light.dir().fX *
+                                                     SkIntToScalar(SkColorGetB(povDepthColor)));
+                    int yOffset = SkScalarRoundToInt(light.dir().fY *
+                                                     SkIntToScalar(SkColorGetB(povDepthColor)));
+
+                    int shX = (x + i + xOffset);
+                    int shY = (y + yOffset);
+
+                    shX = SkClampPos(shX);
+                    shY = SkClampPos(shY);
+
+                    shX = SkClampMax(shX, light.getShadowMap()->width() - 1);
+                    shY = SkClampMax(shY, light.getShadowMap()->height() - 1);
+
+                    int shDepth = 0;
+                    int pvDepth = SkColorGetB(povDepthColor); // depth stored in blue channel
+
+                    if (shPixels[nonAmbLightCnt]) {
+                        uint32_t pix = *shPixels[nonAmbLightCnt]->addr32(shX, shY);
+                        SkColor shColor(pix);
+
+                        shDepth += SkColorGetB(shColor);
+                    } else {
+                        // TODO: handle not being able to read shadow map pixels
+                    }
+
+                    if (pvDepth >= shDepth) {
+                        // assume object normals are pointing straight up
+                        totalLight.fX += light.dir().fZ * light.color().fX;
+                        totalLight.fY += light.dir().fZ * light.color().fY;
+                        totalLight.fZ += light.dir().fZ * light.color().fZ;
+                    }
+                    nonAmbLightCnt++;
+                } else if (light.type() == SkLights::Light::kAmbient_LightType) {
+                    totalLight += light.color();
                 }
             }
 
-            result[i] = convert(accum, SkColorGetA(diffColor));
+            totalColor.fX += SkColorGetR(diffColor) * totalLight.fX;
+            totalColor.fY += SkColorGetG(diffColor) * totalLight.fY;
+            totalColor.fZ += SkColorGetB(diffColor) * totalLight.fZ;
+
+            result[i] = convert(totalColor, SkColorGetA(diffColor));
         }
 
         result += n;
         x += n;
         count -= n;
     } while (count > 0);
+
+    for (int i = 0; i < SkShadowShader::kMaxNonAmbientLights; i++) {
+        if (shPixels[i]) {
+            delete shPixels[i];
+        }
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////