Made shadows blurry (thru implementing variance mapping)

include/core/SkCanvas.h

Index: include/core/SkCanvas.h
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 26e3c8e3c52bf98590650f7be13f19012b866be4..e43b80bb5b6b518187f2a8adcc60c290b855fa7a 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -40,6 +40,18 @@ class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 

[robertphillips, 2016/08/15 23:00:24]

Would SkShadowParams be clearer?

dox!

[vjiaoblack, 2016/08/16 14:16:40]

Done.

+struct SkShadowType {
+    SkScalar fShadowRadius;
+    SkScalar fBiasingConstant;
+    SkScalar fMinVariance;
+
+    enum BlurAlgorithm {
+        kNoBlur_BlurAlgorithm,
+        kVariance_BlurAlgorithm
+    };
+    BlurAlgorithm fBlurAlgorithm;
+};
+
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
@@ -1104,7 +1116,7 @@ public:
 
 #ifdef SK_EXPERIMENTAL_SHADOWING
     /**
-     *  Draw the picture into this canvas.
+     *  Draw the picture into this canvas, with shadows!
      *
      *  We will use the canvas's lights along with the picture information (draw depths of
      *  objects, etc) to first create a set of shadowmaps for the light-picture pairs, and
@@ -1119,14 +1131,33 @@ public:
      *  This is logically equivalent to
      *      saveLayer(paint)/drawPicture/restore
      *
+     *  We also support using variance shadow maps for blurred shadows; the user can specify
+     *  what shadow mapping algorithm to use with sType.
+     *    - Variance Shadow Mapping works by storing both the depth and depth^2 in the shadow map.
+     *    - Then, the shadow map can be blurred, and when reading from it, the fragment shader
+     *      can calculate the variance of the depth at a position by doing E(x^2) - E(x)^2.
+     *    - We can then use the depth variance and depth at a fragment to arrive at an upper bound
+     *      of the probability that the current surface is shadowed by using Chebyshev's
+     *      inequality, and then use that to shade the fragment.
+     *
+     *    - There are a few problems with VSM.
+     *      * Light Bleeding | Areas with high variance, such as near the edges of high up rects,
+     *                         will cause their shadow penumbras to overwrite otherwise solid
+     *                         shadows.
+     *      * Shape Distortion | We can combat Light Bleeding by biasing the shadow (setting
+     *                           mostly shaded fragments to completely shaded) and increasing
+     *                           the minimum allowed variance. However, this warps and rounds
+     *                           out the shape of the shadow.
      */
     void drawShadowedPicture(const SkPicture*,
                              const SkMatrix* matrix,
-                             const SkPaint* paint);
+                             const SkPaint* paint,
+                             const SkShadowType& sType);
     void drawShadowedPicture(const sk_sp<SkPicture>& picture,
                              const SkMatrix* matrix,
-                             const SkPaint* paint) {
-        this->drawShadowedPicture(picture.get(), matrix, paint);
+                             const SkPaint* paint,
+                             const SkShadowType& sType) {
+        this->drawShadowedPicture(picture.get(), matrix, paint, sType);
     }
 #endif
 
@@ -1496,7 +1527,8 @@ protected:
 #ifdef SK_EXPERIMENTAL_SHADOWING
     virtual void onDrawShadowedPicture(const SkPicture*,
                                        const SkMatrix*,
-                                       const SkPaint*);
+                                       const SkPaint*,
+                                       const SkShadowType& sType);
 #endif
     
     // Returns the canvas to be used by DrawIter. Default implementation