Made shadows blurry (thru implementing variance mapping)

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 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.
  */
 
 #include "SkBitmapDevice.h"
+#include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkClipStack.h"
 #include "SkColorFilter.h"
 #include "SkDraw.h"
 #include "SkDrawable.h"
+#include "GrDrawContext.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkErrorInternals.h"
 #include "SkImage.h"
 #include "SkImage_Base.h"
 #include "SkImageFilter.h"
 #include "SkImageFilterCache.h"
 #include "SkLatticeIter.h"
+#include "SkLights.h"
+#include "SkMatrix.h"
 #include "SkMatrixUtils.h"
 #include "SkMetaData.h"
+#include "SkNormalSource.h"
+#include "SkPaintFilterCanvas.h"
 #include "SkPaintPriv.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
+#include "SkPictureRecorder.h"
 #include "SkRasterClip.h"
 #include "SkReadPixelsRec.h"
 #include "SkRRect.h"
 #include "SkShadowPaintFilterCanvas.h"
-#include "SkShadowShader.h"
 #include "SkSmallAllocator.h"
 #include "SkSpecialImage.h"
+#include "SkSurface.h"
 #include "SkSurface_Base.h"
 #include "SkTextBlob.h"
 #include "SkTextFormatParams.h"
 #include "SkTLazy.h"
 #include "SkTraceEvent.h"
-
+#include "../../include/effects/SkBlurImageFilter.h"
 #include <new>
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrRenderTarget.h"
 #include "SkGrPriv.h"
+#include "SkShadowShader.h"
+
 #endif
 
 #define RETURN_ON_NULL(ptr)     do { if (nullptr == (ptr)) return; } while (0)
 
 //#define SK_SUPPORT_PRECHECK_CLIPRECT
 
 /*
  *  Return true if the drawing this rect would hit every pixels in the canvas.
  *
  *  Returns false if
@@ skipping 2996 matching lines @@
         }
     }
 
     SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
     picture->playback(this);
 }
 
 #ifdef SK_EXPERIMENTAL_SHADOWING
 void SkCanvas::drawShadowedPicture(const SkPicture* picture,
                                    const SkMatrix* matrix,
-                                   const SkPaint* paint) {
+                                   const SkPaint* paint,
+                                   const SkShadowType sType) {

[jvanverth1, 2016/08/15 15:14:43]

const SkShadowType& sType. By using a ref you pass it as a pointer as opposed to
putting the whole struct on the stack.

[vjiaoblack, 2016/08/15 17:43:30]

Done.

     RETURN_ON_NULL(picture);
 
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawShadowedPicture()");
 
-    this->onDrawShadowedPicture(picture, matrix, paint);
+    this->onDrawShadowedPicture(picture, matrix, paint, sType);
 }
 
 void SkCanvas::onDrawShadowedPicture(const SkPicture* picture,
                                      const SkMatrix* matrix,
-                                     const SkPaint* paint) {
+                                     const SkPaint* paint,
+                                     const SkShadowType sType) {

[jvanverth1, 2016/08/15 16:37:16]

const &

[vjiaoblack, 2016/08/15 17:43:30]

Done.

     if (!paint || paint->canComputeFastBounds()) {
         SkRect bounds = picture->cullRect();
         if (paint) {
             paint->computeFastBounds(bounds, &bounds);
         }
         if (matrix) {
             matrix->mapRect(&bounds);
         }
         if (this->quickReject(bounds)) {
             return;
         }
     }
 
     SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
 
+    sk_sp<SkImage> povDepthMap;
+    sk_sp<SkImage> diffuseMap;
+
+    // TODO: pass the depth to the shader in vertices, or uniforms
+    //       so we don't have to render depth and color separately
     for (int i = 0; i < fLights->numLights(); ++i) {
         // skip over ambient lights; they don't cast shadows
         // lights that have shadow maps do not need updating (because lights are immutable)
 
         if (SkLights::Light::kAmbient_LightType == fLights->light(i).type() ||
             fLights->light(i).getShadowMap() != nullptr) {
             continue;
         }
 
         // TODO: compute the correct size of the depth map from the light properties
         // TODO: maybe add a kDepth_8_SkColorType
         // TODO: find actual max depth of picture
         SkISize shMapSize = SkShadowPaintFilterCanvas::ComputeDepthMapSize(
                                     fLights->light(i), 255,
                                     picture->cullRect().width(),
                                     picture->cullRect().height());
 
         SkImageInfo info = SkImageInfo::Make(shMapSize.fWidth, shMapSize.fHeight,
                                              kBGRA_8888_SkColorType,
                                              kOpaque_SkAlphaType);
 
         // Create a new surface (that matches the backend of canvas)
         // for each shadow map
         sk_sp<SkSurface> surf(this->makeSurface(info));
 
         // Wrap another SPFCanvas around the surface
         sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
                 sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());
+        depthMapCanvas->setShadowType(sType);
 
         // set the depth map canvas to have the light we're drawing.
         SkLights::Builder builder;
         builder.add(fLights->light(i));
         sk_sp<SkLights> curLight = builder.finish();
+        depthMapCanvas->setLights(curLight);
 
-        depthMapCanvas->setLights(std::move(curLight));
         depthMapCanvas->drawPicture(picture);
+        sk_sp<SkImage> depthMap = surf->makeImageSnapshot();
 
-        fLights->light(i).setShadowMap(surf->makeImageSnapshot());
+        // we blur the variance map
+        SkPaint blurPaint;
+        if (sType.fBlurAlgorithm != SkShadowType::kNoBlur_BlurAlgorithm) {
+            blurPaint.setImageFilter(SkBlurImageFilter::Make(sType.fShadowRadius,
+                                                             sType.fShadowRadius, nullptr));
+        }
+
+        SkImageInfo blurInfo = SkImageInfo::Make(shMapSize.fWidth, shMapSize.fHeight,
+                                                 kBGRA_8888_SkColorType,
+                                                 kOpaque_SkAlphaType);
+
+        sk_sp<SkSurface> blurSurf(this->makeSurface(blurInfo));
+        sk_sp<SkCanvas> blurDepthMapCanvas = sk_ref_sp(blurSurf->getCanvas());
+
+        blurDepthMapCanvas->drawImage(depthMap, 0, 0, &blurPaint);
+
+        fLights->light(i).setShadowMap(blurSurf->makeImageSnapshot());
     }
 
-    sk_sp<SkImage> povDepthMap;
-    sk_sp<SkImage> diffuseMap;
-
-    // TODO: pass the depth to the shader in vertices, or uniforms
-    //       so we don't have to render depth and color separately
-
     // povDepthMap
     {
         SkLights::Builder builder;
         builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),
                                     SkVector3::Make(0.0f, 0.0f, 1.0f)));
         sk_sp<SkLights> povLight = builder.finish();
 
         SkImageInfo info = SkImageInfo::Make(picture->cullRect().width(),
                                              picture->cullRect().height(),
                                              kBGRA_8888_SkColorType,
                                              kOpaque_SkAlphaType);
 
         // Create a new surface (that matches the backend of canvas)
         // to create the povDepthMap
         sk_sp<SkSurface> surf(this->makeSurface(info));
 
         // Wrap another SPFCanvas around the surface
         sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
                 sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());
 
         // set the depth map canvas to have the light as the user's POV
         depthMapCanvas->setLights(std::move(povLight));
 
         depthMapCanvas->drawPicture(picture);
-
         povDepthMap = surf->makeImageSnapshot();
     }
 
     // diffuseMap
     {
         SkImageInfo info = SkImageInfo::Make(picture->cullRect().width(),
                                              picture->cullRect().height(),
                                              kBGRA_8888_SkColorType,
                                              kOpaque_SkAlphaType);
 
         sk_sp<SkSurface> surf(this->makeSurface(info));
         surf->getCanvas()->drawPicture(picture);
 
         diffuseMap = surf->makeImageSnapshot();
     }
-
     SkPaint shadowPaint;
 
     sk_sp<SkShader> povDepthShader = povDepthMap->makeShader(SkShader::kClamp_TileMode,
                                                              SkShader::kClamp_TileMode);
-
     sk_sp<SkShader> diffuseShader = diffuseMap->makeShader(SkShader::kClamp_TileMode,
                                                            SkShader::kClamp_TileMode);
-
     sk_sp<SkShader> shadowShader = SkShadowShader::Make(std::move(povDepthShader),
                                                         std::move(diffuseShader),
                                                         std::move(fLights),
                                                         diffuseMap->width(),
-                                                        diffuseMap->height());
+                                                        diffuseMap->height(),
+                                                        sType);
 
     shadowPaint.setShader(shadowShader);
 
     this->drawRect(SkRect::MakeIWH(diffuseMap->width(), diffuseMap->height()), shadowPaint);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 97 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif