raster shadows

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 43 matching lines @@
 
         uint32_t getFlags() const override { return fFlags; }
 
     private:
         SkShader::Context*        fPovDepthContext;
         SkShader::Context*        fDiffuseContext;
         uint32_t                  fFlags;
 
         void* fHeapAllocated;
 
+        int fNonAmbLightCnt;

[robertphillips, 2016/08/29 18:03:40]

This should be SkPixmap*

[vjiaoblack, 2016/08/29 18:22:07]

Done.

+        SkPixmap** fShadowMapPixels;
+
+
         typedef SkShader::Context INHERITED;
     };
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkShadowShaderImpl)
 
 protected:
     void flatten(SkWriteBuffer&) const override;
     size_t onContextSize(const ContextRec&) const override;
     Context* onCreateContext(const ContextRec&, void*) const override;
@@ skipping 561 matching lines @@
         , fHeapAllocated(heapAllocated) {
     bool isOpaque = shader.isOpaque();
 
     // update fFlags
     uint32_t flags = 0;
     if (isOpaque && (255 == this->getPaintAlpha())) {
         flags |= kOpaqueAlpha_Flag;
     }
 
     fFlags = flags;
+
+    const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
+

[robertphillips, 2016/08/29 18:03:39]

fShadowMapPixels = new SkPixmap[fNonAmbLightCnt];

[vjiaoblack, 2016/08/29 18:22:07]

Done.

+    fShadowMapPixels = new SkPixmap*[SkShadowShader::kMaxNonAmbientLights];
+
+    fNonAmbLightCnt = lightShader.fLights->numLights();
+    for (int i = 0; i < fNonAmbLightCnt; i++) {
+        if (lightShader.fLights->light(i).type() == SkLights::Light::kDirectional_LightType) {
+            lightShader.fLights->light(i).getShadowMap()->

[robertphillips, 2016/08/29 18:03:39]

shouldn't fNonAmbLightCnt be i here ?

[vjiaoblack, 2016/08/29 18:22:07]

Done.

+                    peekPixels(fShadowMapPixels[fNonAmbLightCnt]);
+        }

[robertphillips, 2016/08/29 18:03:39]

else {
   fShadowMapPixels[i].reset();
}

- this isn't really necessary though

[vjiaoblack, 2016/08/29 18:22:07]

Yeah, because the uninitialized ones just will be empty, right?

I won't add it, unless really think I should.

+    }
 }
 
 SkShadowShaderImpl::ShadowShaderContext::~ShadowShaderContext() {
     // The dependencies have been created outside of the context on memory that was allocated by
     // the onCreateContext() method. Call the destructors and free the memory.
     fPovDepthContext->~Context();
     fDiffuseContext->~Context();
 
     sk_free(fHeapAllocated);
+

[robertphillips, 2016/08/29 18:03:39]

This can then become "delete [] fShadowMapPixels;"

[vjiaoblack, 2016/08/29 18:22:07]

Done.

+    for (int i = 0; i < SkShadowShader::kMaxNonAmbientLights; i++) {
+        if (fShadowMapPixels[i] && fShadowMapPixels[i]->height() > 0) {
+            delete fShadowMapPixels[i];
+        }
+    }

[robertphillips, 2016/08/29 18:03:39]

as is, you're leaking fShadowMapPixels itself here

[vjiaoblack, 2016/08/29 18:22:07]

Done.

 }
 
 static inline SkPMColor convert(SkColor3f color, U8CPU a) {
     if (color.fX <= 0.0f) {
         color.fX = 0.0f;
     } else if (color.fX >= 255.0f) {
         color.fX = 255.0f;
     }
 
     if (color.fY <= 0.0f) {
@@ skipping 12 matching lines @@
 }
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each one here costs 16 bytes)
 #define BUFFER_MAX 16
 void SkShadowShaderImpl::ShadowShaderContext::shadeSpan(int x, int y,
                                                         SkPMColor result[], int count) {
     const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
 
     SkPMColor diffuse[BUFFER_MAX];
+    SkPMColor povDepth[BUFFER_MAX];
 
     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]);
+            SkColor povDepthColor = povDepth[i];
 
-            SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[i]);
-
-            SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
+            SkColor3f totalColor = SkColor3f::Make(0.0f, 0.0f, 0.0f);
+            SkColor3f totalLight = lightShader.fLights->ambientLightColor();
             // This is all done in linear unpremul color space (each component 0..255.0f though)
 

[robertphillips, 2016/08/29 18:03:40]

Do you intend to be changing fNonAmbLightCnt in this method ?

[vjiaoblack, 2016/08/29 18:22:07]

nope, good catch. Thanks.

-            accum.fX += lightShader.fLights->ambientLightColor().fX * SkColorGetR(diffColor);
-            accum.fY += lightShader.fLights->ambientLightColor().fY * SkColorGetG(diffColor);
-            accum.fZ += lightShader.fLights->ambientLightColor().fZ * SkColorGetB(diffColor);
-
+            fNonAmbLightCnt = 0;
             for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
                 const SkLights::Light& light = lightShader.fLights->light(l);
 
-                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);
+                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 (fShadowMapPixels[fNonAmbLightCnt] &&
+                        fShadowMapPixels[fNonAmbLightCnt]->height() > 0) {
+                        uint32_t pix = *fShadowMapPixels[fNonAmbLightCnt]->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;
+                    }
+                    fNonAmbLightCnt++;
                 } else {
-                    accum.fX += light.color().fX * SkColorGetR(diffColor);
-                    accum.fY += light.color().fY * SkColorGetG(diffColor);
-                    accum.fZ += light.color().fZ * SkColorGetB(diffColor);
+                    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);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
@@ skipping 102 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif