Made shadows blurry (thru implementing variance mapping)

src/utils/SkShadowPaintFilterCanvas.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPathEffect.h"
 #include "SkShadowPaintFilterCanvas.h"
 
 #ifdef SK_EXPERIMENTAL_SHADOWING
 
 SkShadowPaintFilterCanvas::SkShadowPaintFilterCanvas(SkCanvas *canvas)
-        : SkPaintFilterCanvas(canvas) { }
+        : SkPaintFilterCanvas(canvas) {
+    fShadowType.fShadowRadius = 0.0f;
+    fShadowType.fBlurAlgorithm = SkShadowType::kNoBlur_BlurAlgorithm;
+    fShadowType.fBiasingConstant = 0.0f;
+    fShadowType.fMinVariance = 0.0f;
+}
 
 // TODO use a shader instead
 bool SkShadowPaintFilterCanvas::onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const {
     if (*paint) {
         int z = this->getZ();
         SkASSERT(z <= 0xFF && z >= 0x00);
 
         SkPaint newPaint;
         newPaint.setPathEffect(sk_ref_sp<SkPathEffect>((*paint)->getPathEffect()));
 
         SkColor color = 0xFF000000; // init color to opaque black
         color |= z; // Put the index into the blue component
+
+        if (fShadowType.fBlurAlgorithm == SkShadowType::kVariance_BlurAlgorithm) {
+            int z2 = z * z;
+            if (z2 > 255 * 256) {
+                color |= 0xff00;
+            } else {
+                // Let's only store the more significant bits of z2 to save space.
+                // In practice, this should barely impact shadow blur quality.
+                color |= z2 & 0x0000ff00;
+            }
+        }
         newPaint.setColor(color);
 
         *paint->writable() = newPaint;
     }
 
     return true;
 }
 
 SkISize SkShadowPaintFilterCanvas::ComputeDepthMapSize(const SkLights::Light& light, int maxDepth,
                                                        int width, int height) {
     SkASSERT(light.type() != SkLights::Light::kAmbient_LightType);
     int dMapWidth = SkMin32(maxDepth * fabs(light.dir().fX) + width,
                             width * 2);
     int dMapHeight = SkMin32(maxDepth * fabs(light.dir().fY) + height,
                              height * 2);
     return SkISize::Make(dMapWidth, dMapHeight);
 }
 
+void SkShadowPaintFilterCanvas::setShadowType(SkShadowType sType) {

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

const &

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

Done.

+    fShadowType = sType;
+}
 
 void SkShadowPaintFilterCanvas::onDrawPicture(const SkPicture *picture, const SkMatrix *matrix,
                                               const SkPaint *paint) {
     SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
     if (this->onFilter(&filteredPaint, kPicture_Type)) {
         SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
     }
 }
 
 void SkShadowPaintFilterCanvas::updateMatrix() {
@@ skipping 157 matching lines @@
 }
 
 void SkShadowPaintFilterCanvas::onDrawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y,
                                                const SkPaint &paint) {
     this->updateMatrix();
     this->INHERITED::onDrawTextBlob(blob, x, y, paint);
     this->restore();
 }
 
 #endif