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
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkImage.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkRegion.h"
 #include "SkSurfaceProps.h"
 #include "SkXfermode.h"
 #include "SkLights.h"
+#include "../../src/core/SkShadowShader.h"
 
 class GrContext;
 class GrDrawContext;
 class SkBaseDevice;
 class SkCanvasClipVisitor;
 class SkClipStack;
 class SkData;
 class SkDraw;
 class SkDrawable;
 class SkDrawFilter;
@@ skipping 1066 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,
+                             SkShadowType sType);

[jvanverth1, 2016/08/12 17:39:08]

We pass a struct as const& if it's not modified.

[vjiaoblack, 2016/08/12 19:07:42]

Done.

     void drawShadowedPicture(const sk_sp<SkPicture>& picture,
                              const SkMatrix* matrix,
-                             const SkPaint* paint) {
-        this->drawShadowedPicture(picture.get(), matrix, paint);
+                             const SkPaint* paint,
+                             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*,
+                                       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