Made shadows blurry (thru implementing variance mapping)

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 21 matching lines @@
 class SkMetaData;
 class SkPath;
 class SkPicture;
 class SkPixmap;
 class SkRasterClip;
 class SkRRect;
 struct SkRSXform;
 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).
     This includes a reference to the device itself, and a stack of matrix/clip
     values. For any given draw call (e.g. drawRect), the geometry of the object
     being drawn is transformed by the concatenation of all the matrices in the
     stack. The transformed geometry is clipped by the intersection of all of
     the clips in the stack.
 
     While the Canvas holds the state of the drawing device, the state (style)
@@ skipping 1044 matching lines @@
      *  This is logically equivalent to
      *      saveLayer(paint)/drawPicture/restore
      */
     void drawPicture(const SkPicture*, const SkMatrix* matrix, const SkPaint* paint);
     void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint) {
         this->drawPicture(picture.get(), matrix, paint);
     }
 
 #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
      *  then use that set of shadowmaps to render the scene with shadows.
      *
      *  If matrix is non-null, apply that matrix to the CTM when drawing this picture. This is
      *  logically equivalent to
      *      save/concat/drawPicture/restore
      *
      *  If paint is non-null, draw the picture into a temporary buffer, and then apply the paint's
      *  alpha/colorfilter/imagefilter/xfermode to that buffer as it is drawn to the canvas.
      *  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
 
     enum VertexMode {
         kTriangles_VertexMode,
         kTriangleStrip_VertexMode,
         kTriangleFan_VertexMode
     };
 
     /** Draw the array of vertices, interpreted as triangles (based on mode).
@@ skipping 349 matching lines @@
     virtual void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle);
     virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op);
 
     virtual void onDiscard();
 
     virtual void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*);
 
 #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
     // returns this. Subclasses that encapsulate an indirect canvas may
     // need to overload this method. The impl must keep track of this, as it
     // is not released or deleted by the caller.
     virtual SkCanvas* canvasForDrawIter();
 
     // Clip rectangle bounds. Called internally by saveLayer.
     // returns false if the entire rectangle is entirely clipped out
@@ skipping 208 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif