Made shadows blurry (thru implementing variance mapping)

tools/debugger/SkDrawCommand.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDrawCommand.h"
 
 #include "SkBlurMaskFilter.h"
@@ skipping 2431 matching lines @@
     : INHERITED(kEndDrawPicture_OpType) , fRestore(restore) { }
 
 void SkEndDrawPictureCommand::execute(SkCanvas* canvas) const {
     if (fRestore) {
         canvas->restore();
     }
 }
 
 SkBeginDrawShadowedPictureCommand::SkBeginDrawShadowedPictureCommand(const SkPicture* picture,
                                                                      const SkMatrix* matrix,
-                                                                     const SkPaint* paint)
+                                                                     const SkPaint* paint,
+                                                                     const SkShadowParams& params)
         : INHERITED(kBeginDrawShadowedPicture_OpType)
         , fPicture(SkRef(picture)) {
 
     SkString* str = new SkString;
-    str->appendf("SkPicture: L: %f T: %f R: %f B: %f",
+    str->appendf("SkPicture: L: %f T: %f R: %f B: %f\n",
                  picture->cullRect().fLeft, picture->cullRect().fTop,
                  picture->cullRect().fRight, picture->cullRect().fBottom);
+    str->appendf("SkShadowParams: bias:%f, minVariance:%f, shRadius:%f, shType:%d\n",
+                   params.fBiasingConstant,
+                   params.fMinVariance,
+                   params.fShadowRadius,
+                   params.fType);
     fInfo.push(str);
 
     if (matrix) {
         fMatrix.set(*matrix);
         fInfo.push(SkObjectParser::MatrixToString(*matrix));
     }
 
     if (paint) {
         fPaint.set(*paint);
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
+    fShadowParams = params;
 }
 
 void SkBeginDrawShadowedPictureCommand::execute(SkCanvas* canvas) const {
     if (fPaint.isValid()) {
         SkRect bounds = fPicture->cullRect();
         if (fMatrix.isValid()) {
             fMatrix.get()->mapRect(&bounds);
         }
         canvas->saveLayer(&bounds, fPaint.get());
     }
 
     if (fMatrix.isValid()) {
         if (!fPaint.isValid()) {
             canvas->save();
         }
         canvas->concat(*fMatrix.get());
     }
 }
 
 bool SkBeginDrawShadowedPictureCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
 
     xlate_and_scale_to_bounds(canvas, fPicture->cullRect());
-
-    canvas->drawPicture(fPicture.get());
-
+    canvas->drawShadowedPicture(fPicture.get(), fMatrix.get(), fPaint.get(), fShadowParams);
     canvas->restore();
 
     return true;
 }
 
 SkEndDrawShadowedPictureCommand::SkEndDrawShadowedPictureCommand(bool restore)
         : INHERITED(kEndDrawShadowedPicture_OpType) , fRestore(restore) { }
 
 void SkEndDrawShadowedPictureCommand::execute(SkCanvas* canvas) const {
     if (fRestore) {
@@ skipping 951 matching lines @@
 SkTranslateZCommand* SkTranslateZCommand::fromJSON(Json::Value& command,
                                        UrlDataManager& urlDataManager) {
     SkScalar z;
 #ifdef SK_EXPERIMENTAL_SHADOWING
     extract_json_scalar(command[SKDEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS], &z);
 #else
     z = 0;
 #endif
     return new SkTranslateZCommand(z);
 }